免费的游戏网站建设,网站怎么做3d商品浏览,开发板哪个好,做铜字接单网站文章目录 前言一、单一职责 #x1f367;1、单一职责原则注意事项和细节2、代码实现2、1 错误示例2、2 正确示例但有缺陷2、3 最终形态 二、接口隔离原则 #x1f969;1、代码示例 三、依赖倒转原则 #x1f965;1、代码示例2、依赖关系传递的三种方式 四、里氏替换原则 1、单一职责原则注意事项和细节2、代码实现2、1 错误示例2、2 正确示例但有缺陷2、3 最终形态 二、接口隔离原则 1、代码示例 三、依赖倒转原则 1、代码示例2、依赖关系传递的三种方式 四、里氏替换原则 问题的引出子类无意间重写了父类的方法导致业务逻辑发生错误解决方案继承同一基类使用组合 五、开闭原则 方式1方式 1 的缺点方式2 进行改进 六、迪米特法则 错误示例正确示例 七、合成复用原则 总结 设计原则核心思想 前言 设计模式原则其实就是程序员在编程时应当遵守的原则也是各种设计模式的基础(即:设计模式为什么这样设计的依据) 设计模式常用的七大原则有: 1、单一职责原则 2、 接口隔离原则3、依赖倒转(倒置)原则4、里氏替换原则5、开闭原则6、 迪米特法则7、 合成复用原则 一、单一职责
对类来说的即一个类应该只负责一项职责。如类A 负责两个不同职责: 职责 1职责 2。当职责1需求变更而改变 A 时可能造成职责 2 执行错误所以需要将类 A 的粒度分解为 A1A2。 例如我们平常用来操作数据库的实体类每个实体类都对应着一张表这就体现出了单一职责的各司其职。controller和service也都是一一对应各司其职也是单一职责的表现 1、单一职责原则注意事项和细节 降低类的复杂度一个类只负责一项职责。提高类的可读性可维护性降低变更引起的风险通常情况下我们应当遵守单一职责原则只有逻辑足够简单才可以在代码级违反单一职责原则只有类中方法数量足够少可以在方法级别保持单一职责原则 2、代码实现
2、1 错误示例
public class SingleResponsibility1 {public static void main(String[]{Vehicle vehicle new Vehicle();vehicle.run(摩托车);vehicle.run(汽车);vehicle.run(飞机);}
}// 交通工具类
// 方式 1
// 1. 在方式 1 的 run 方法中违反了单一职责原则
// 2. 解决的方案非常的简单根据交通工具运行方法不同分解成不同类即可
class Vehicle {public void run(String vehicle) {System.out.println(vehicle 在公路上运行....);}
}
2、2 正确示例但有缺陷
public class SingleResponsibility2 {public static void main(String[] args){RoadVehicle roadVehicle new RoadVehicle();roadVehicle.run(摩托车);roadVehicle.run(汽车);AirVehicle airVehicle new AirVehicle();airVehicle.run(飞机);}
}//方案 2 的分析
//1. 遵守单一职责原则
//2. 但是这样做的改动很大即将类分解同时修改客户端
//3. 改进直接修改 Vehicle 类改动的代码会比较少方案 3
class RoadVehicle {public void run(String vehicle) {System.out.println(vehicle 公路运行);}
}class AirVehicle {public void run(String vehicle) {System.out.println(vehicle 天空运行);}
}class WaterVehicle {public void run(String vehicle) {System.out.println(vehicle 水中运行);}
}
2、3 最终形态
public class SingleResponsibility3 {public static void main(String[] args) {Vehicle2 vehicle2 new Vehicle2();vehicle2.run(汽车);vehicle2.runWater(轮船);vehicle2.runAir(飞机);}
}//方式 3的分析//1. 这种修改方法没有对原来的类做大的修改只是增加方法
//2. 这里虽然没有在类这个级别上遵守单一职责原则但是在方法级别上仍然是遵守单一职责
class Vehicle2 {public void run(String vehicle) {//处理System.out.println(vehicle 在公路上运行....);}public void runAir(String vehicle) {System.out.println(vehicle 在天空上运行....);}public void runWater(String vehicle) {System.out.println(vehicle 在水中行....);}} 二、接口隔离原则 1、代码示例
package shejimoshi;public class test1 {public static void main(String[] args) {
// TODO Auto-generated method stub
// 使用一把A a new A();a.depend1(new B()); // A 类通过接口去依赖 B 类a.depend2(new B());a.depend3(new B());C c new C();c.depend1(new D()); // C 类通过接口去依赖(使用)D 类c.depend4(new D());c.depend5(new D());}}// 接口 1
interface Interface1 {void operation1();
}
// 接口 2
interface Interface2 {void operation2();void operation3();
}
// 接口 3
interface Interface3 {void operation4();void operation5();
}class B implements Interface1, Interface2 {Overridepublic void operation1() {System.out.println(B 实现了 operation1);}Overridepublic void operation2() {System.out.println(B 实现了 operation2);}Overridepublic void operation3() {System.out.println(B 实现了 operation3);}
}class D implements Interface1, Interface3 {Overridepublic void operation1() {System.out.println(D 实现了 operation1);}Overridepublic void operation4() {System.out.println(D 实现了 operation4);}Overridepublic void operation5() {System.out.println(D 实现了 operation5);}
}class A { // A 类通过接口 Interface1,Interface2 依赖(使用) B 类但是只会用到 1,2,3 方法public void depend1(Interface1 i) {i.operation1();}public void depend2(Interface2 i) {i.operation2();}public void depend3(Interface2 i) {i.operation3();}
}
class C { // C 类通过接口 Interface1,Interface3 依赖(使用) D 类但是只会用到 1,4,5 方法public void depend1(Interface1 i) {i.operation1();}public void depend4(Interface3 i) {i.operation4();}public void depend5(Interface3 i) {i.operation5();}
}输出
B 实现了 operation1
B 实现了 operation2
B 实现了 operation3
D 实现了 operation1
D 实现了 operation4
D 实现了 operation5三、依赖倒转原则 1、代码示例 正常代码没有加入设计模式 //完成 Person 接收消息的功能 //方式 1 分析 //1. 简单比较容易想到 //2. 如果我们获取的对象是 微信短信等等则新增类同时 Perons 也要增加相应的接收方法 //3. 解决思路引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖 // 因为 Email, WeiXin 等等属于接收的范围他们各自实现 IReceiver 接口就 ok, 这样我们就符合依赖倒转原则 package shejimoshi;public class test2 {public static void main(String[] args) {Person person new Person();person.receive(new Email());}}class Email {public String getInfo() {return 电子邮件信息: hello,world;}
}//完成 Person 接收消息的功能
//方式 1 分析
//1. 简单比较容易想到
//2. 如果我们获取的对象是 微信短信等等则新增类同时 Perons 也要增加相应的接收方法
//3. 解决思路引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
// 因为 Email, WeiXin 等等属于接收的范围他们各自实现 IReceiver 接口就 ok, 这样我们就符合依赖倒转原则
class Person {public void receive(Email email ) {System.out.println(email.getInfo());}
}输出
电子邮件信息: hello,world 加入设计模式依赖倒转原则 package shejimoshi;public class test2 {public static void main(String[] args) {//客户端无需改变Person person new Person();person.receive(new Email());person.receive(new WeiXin());}}//定义接口
interface IReceiver {public String getInfo();
}//增加微信
class WeiXin implements IReceiver {public String getInfo() {return 微信信息: hello,ok;}
}class Email implements IReceiver {public String getInfo() {return 电子邮件信息: hello,world;}
}class Person {public void receive(IReceiver iReceiver ) {System.out.println(iReceiver.getInfo());}
}输出
电子邮件信息: hello,world
微信信息: hello,ok
2、依赖关系传递的三种方式 三种方式代码示例 package shejimoshi;public class DependencyPass {public static void main(String[] args) {
// TODO Auto-generated method stubChangHong changHong new ChangHong();OpenAndClose openAndClose new OpenAndClose();openAndClose.open(changHong);//通过构造器进行依赖传递
// OpenAndClose openAndClose new OpenAndClose(changHong);
// openAndClose.open();//通过 setter 方法进行依赖传递
// OpenAndClose openAndClose new OpenAndClose();
// openAndClose.setTv(changHong);
// openAndClose.open();}
}// 方式 1 通过接口传递实现依赖
// 开关的接口interface IOpenAndClose {public void open(ITV tv); //抽象方法,接收接口
}interface ITV { //ITV 接口public void play();
}//class ChangHong implements ITV {
//
// Override
// public void play() {
// // TODO Auto-generated method stub
// System.out.println(长虹电视机打开);
// }
//
//}
// 实现接口
class OpenAndClose implements IOpenAndClose{public void open(ITV tv){tv.play();}
}
// 方式 2: 通过构造方法依赖传递
//interface IOpenAndClose {
// public void open(); //抽象方法
//}
//interface ITV { //ITV 接口
// public void play();
//}
//class OpenAndClose implements IOpenAndClose{
// public ITV tv; //成员
// public OpenAndClose(ITV tv){ //构造器
// this.tv tv;
// }
// public void open(){
// this.tv.play();
// }
//}
// 方式 3 , 通过 setter 方法传递
//interface IOpenAndClose {
// public void open(); // 抽象方法
// public void setTv(ITV tv);
//}
//interface ITV { // ITV 接口
// public void play();
//}
//class OpenAndClose implements IOpenAndClose {
// private ITV tv;
// public void setTv(ITV tv) {
// this.tv tv;
// }
// public void open() {
// this.tv.play();
// }
//}
class ChangHong implements ITV {Overridepublic void play() {
// TODO Auto-generated method stubSystem.out.println(长虹电视机打开);}
} 四、里氏替换原则 我们在写代码的平常很多地方会用到继承这大大便利了我们程序的便利但也带来了很多弊端父类的修改可能会造成子类的故障子类继承父类重写父类的方法后如果父类进行了修改就会对继承体系造成一些不可预知的侵入性这时我们尽量不让子类去重写父类的方法而是将子类和父类设计为兄长类平起平坐把两个类公共的方法抽象成一个抽象类两个类都去继承抽象类这样都具有了相同的行为而一些特有的行为也不会影响到对方。 问题的引出子类无意间重写了父类的方法导致业务逻辑发生错误
package shejimoshi;public class Liskov {public static void main(String[] args) {
// TODO Auto-generated method stubA a new A();System.out.println(11-3 a.func1(11, 3));System.out.println(1-8 a.func1(1, 8));System.out.println(-----------------------);B b new B();//这里本意是求出 11-3, 但由于子类不经意间重写了父类的方法从而产生了不可预知的错误System.out.println(11-3 b.func1(11, 3));System.out.println(1-8 b.func1(1, 8));// 1-8System.out.println(1139 b.func2(11, 3));}
}// A 类
class A {// 返回两个数的差public int func1(int num1, int num2) {return num1 - num2;}
}
// B 类继承了 A
// 增加了一个新功能完成两个数相加,然后和 9 求和
class B extends A {//这里重写了 A 类的方法, 可能是无意识public int func1(int a, int b) {return a b;}public int func2(int a, int b) {return func1(a, b) 9;}
} 解决方案继承同一基类使用组合
package shejimoshi;public class Liskov {public static void main(String[] args) {
// TODO Auto-generated method stubA a new A();System.out.println(11-3 a.func1(11, 3));System.out.println(1-8 a.func1(1, 8));System.out.println(-----------------------);B b new B();System.out.println(11-3 b.func1(11, 3));//这里本意是求出 11-3System.out.println(1-8 b.func1(1, 8));// 1-8System.out.println(1139 b.func2(11, 3));System.out.println(---------使用组合后);//使用组合仍然可以使用到 A 类相关方法System.out.println(11-3 b.func3(11, 3));// 这里本意是求出 11-}
}//创建一个更加基础的基类
class Base {//把更加基础的方法和成员写到 Base 类public int func1(int num1, int num2) {return num1 - num2;}
}
// A 类
class A extends Base {// 返回两个数的差public int func1(int num1, int num2) {return num1 - num2;}
}
// B 类继承了 A
// 增加了一个新功能完成两个数相加,然后和 9 求和
class B extends Base {//如果 B 需要使用 A 类的方法,使用组合关系private A a new A();//这里重写了 A 类的方法, 可能是无意识public int func1(int a, int b) {return a b;}public int func2(int a, int b) {return func1(a, b) 9;}//我们仍然想使用 A 的方法public int func3(int a, int b) {return this.a.func1(a, b);}
}输出11-38
1-8-7
-----------------------
11-314
1-89
113923
---------使用组合后
11-38
五、开闭原则 方式1
package tanchishell.SJMS.ocp;public class Ocp {public static void main(String[] args) {
//使用看看存在的问题GraphicEditor graphicEditor new GraphicEditor();graphicEditor.drawShape(new Rectangle());graphicEditor.drawShape(new Circle());graphicEditor.drawShape(new Triangle());}
}//这是一个用于绘图的类 [使用方]
class GraphicEditor {//接收 Shape 对象然后根据 type来绘制不同的图形public void drawShape(Shape s) {if (s.m_type 1)drawRectangle(s);else if (s.m_type 2)drawCircle(s);else if (s.m_type 3)drawTriangle(s);}//绘制矩形public void drawRectangle(Shape r) {System.out.println( 绘制矩形 );}//绘制圆形public void drawCircle(Shape r) {System.out.println( 绘制圆形 );}//绘制三角形public void drawTriangle(Shape r) {System.out.println( 绘制三角形 );}
}//Shape 类基类
class Shape {int m_type;
}class Rectangle extends Shape {Rectangle() {super.m_type 1;}
}class Circle extends Shape {Circle() {super.m_type 2;}
}//新增画三角形
class Triangle extends Shape {Triangle() {super.m_type 3;}
}输出绘制矩形 绘制圆形 绘制三角形
方式 1 的缺点 优点是比较好理解简单易操作。缺点是违反了设计模式的 ocp 原则即对扩展开放(提供方)对修改关闭(使用方)。即当我们给类增加新功能的时候尽量不修改代码或者尽可能少修改代码.比如我们这时要新增加一个图形种类 三角形我们需要做如下修改修改的地方较多 方式2 进行改进 思路把创建 Shape 类做成抽象类并提供一个抽象的 draw 方法让子类去实现即可这样我们有新的图形 种类时只需要让新的图形类继承 Shape并实现 draw 方法即可使用方的代码就不需要修 - 满足了开闭原 package tanchishell.SJMS.ocp;public class ocp2 {public static void main(String[] args) {//使用看看存在的问题GraphicEditor graphicEditor new GraphicEditor();graphicEditor.drawShape(new Rectangle());graphicEditor.drawShape(new Circle());graphicEditor.drawShape(new Triangle());graphicEditor.drawShape(new OtherGraphic());}
}//这是一个用于绘图的类 [使用方]
class GraphicEditor {//接收 Shape 对象调用 draw 方法public void drawShape(Shape s) {s.draw();}
}//Shape 类基类
abstract class Shape {int m_type;public abstract void draw();//抽象方法
}
class Rectangle extends Shape {Rectangle() {super.m_type 1;}Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println( 绘制矩形 );}
}
class Circle extends Shape {Circle() {super.m_type 2;}Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println( 绘制圆形 );}
}//新增画三角形
class Triangle extends Shape {Triangle() {super.m_type 3;}Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println( 绘制三角形 );}
}
//新增一个图形
class OtherGraphic extends Shape {OtherGraphic() {super.m_type 4;}Overridepublic void draw() {
// TODO Auto-generated method stubSystem.out.println( 绘制其它图形 );}
}输出绘制矩形 绘制圆形 绘制三角形 绘制其它图形
六、迪米特法则 非直接关系的朋友对象应该在该对象内部实现业务逻辑暴露给外部一个 public 的引用来避免对象间的耦合 错误示例
package tanchishell.SJMS.demeter;import java.util.ArrayList;
import java.util.List;//客户端
public class Demeter1 {public static void main(String[] args) {
//创建了一个 SchoolManager 对象SchoolManager schoolManager new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息schoolManager.printAllEmployee(new CollegeManager());}
}//学校总部员工类
class Employee {private String id;public void setId(String id) {this.id id;}public String getId() {return id;}
}//学院的员工类
class CollegeEmployee {private String id;public void setId(String id) {this.id id;}public String getId() {return id;}
}//管理学院员工的管理类
class CollegeManager {//返回学院的所有员工public ListCollegeEmployee getAllEmployee() {ListCollegeEmployee list new ArrayListCollegeEmployee();for (int i 0; i 10; i) { //这里我们增加了 10 个员工到 listCollegeEmployee emp new CollegeEmployee();emp.setId(学院员工 id i);list.add(emp);}return list;}
}//学校管理类
//分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类这样违背了 迪米特法则
class SchoolManager {//返回学校总部的员工public ListEmployee getAllEmployee() {ListEmployee list new ArrayListEmployee();for (int i 0; i 5; i) { //这里我们增加了 5 个员工到 listEmployee emp new Employee();emp.setId(学校总部员工 id i);list.add(emp);}return list;}//该方法完成输出学校总部和学院员工信息(id)void printAllEmployee(CollegeManager sub) {
//分析问题
//1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
//3. 违反了 迪米特法则
//获取到学院员工ListCollegeEmployee list1 sub.getAllEmployee();System.out.println(------------学院员工------------);for (CollegeEmployee e : list1) {System.out.println(e.getId());}
//获取到学校总部员工ListEmployee list2 this.getAllEmployee();System.out.println(------------学校总部员工------------);for (Employee e : list2) {System.out.println(e.getId());}}
}输出------------学院员工------------
学院员工 id 0
学院员工 id 1
学院员工 id 2
学院员工 id 3
学院员工 id 4
学院员工 id 5
学院员工 id 6
学院员工 id 7
学院员工 id 8
学院员工 id 9
------------学校总部员工------------
学校总部员工 id 0
学校总部员工 id 1
学校总部员工 id 2
学校总部员工 id 3
学校总部员工 id 4
正确示例 package tanchishell.SJMS.demeter;import java.util.ArrayList;
import java.util.List;//客户端
public class Demeter2 {public static void main(String[] args) {
//创建了一个 SchoolManager 对象SchoolManager schoolManager new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息schoolManager.printAllEmployee(new CollegeManager());}
}//学校总部员工类
class Employee {private String id;public void setId(String id) {this.id id;}public String getId() {return id;}
}//学院的员工类
class CollegeEmployee {private String id;public void setId(String id) {this.id id;}public String getId() {return id;}
}//管理学院员工的管理类
class CollegeManager {//返回学院的所有员工public ListCollegeEmployee getAllEmployee() {ListCollegeEmployee list new ArrayListCollegeEmployee();for (int i 0; i 10; i) { //这里我们增加了 10 个员工到 listCollegeEmployee emp new CollegeEmployee();emp.setId(学院员工 id i);list.add(emp);}return list;}public void printEmployee() {
//问题解决
//1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
//3. 违反了 迪米特法则
//获取到学院员工ListCollegeEmployee list1 this.getAllEmployee();System.out.println(------------学院员工------------);for (CollegeEmployee e : list1) {System.out.println(e.getId());}}
}//学校管理类
//分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类这样违背了 迪米特法则
class SchoolManager {//返回学校总部的员工public ListEmployee getAllEmployee() {ListEmployee list new ArrayListEmployee();for (int i 0; i 5; i) { //这里我们增加了 5 个员工到 listEmployee emp new Employee();emp.setId(学校总部员工 id i);list.add(emp);}return list;}//该方法完成输出学校总部和学院员工信息(id)void printAllEmployee(CollegeManager sub) {
//获取到学院员工sub.printEmployee();
//获取到学校总部员工ListEmployee list2 this.getAllEmployee();System.out.println(------------学校总部员工------------);for (Employee e : list2) {System.out.println(e.getId());}}
}输出
------------学院员工------------
学院员工 id 0
学院员工 id 1
学院员工 id 2
学院员工 id 3
学院员工 id 4
学院员工 id 5
学院员工 id 6
学院员工 id 7
学院员工 id 8
学院员工 id 9
------------学校总部员工------------
学校总部员工 id 0
学校总部员工 id 1
学校总部员工 id 2
学校总部员工 id 3
学校总部员工 id 4
七、合成复用原则 总结 设计原则核心思想
文章转载自： http://www.morning.etsaf.com.gov.cn.etsaf.com http://www.morning.rnribht.cn.gov.cn.rnribht.cn http://www.morning.dnbhd.cn.gov.cn.dnbhd.cn http://www.morning.sbjhm.cn.gov.cn.sbjhm.cn http://www.morning.pbygt.cn.gov.cn.pbygt.cn http://www.morning.nfyc.cn.gov.cn.nfyc.cn http://www.morning.znqmh.cn.gov.cn.znqmh.cn http://www.morning.bpmnz.cn.gov.cn.bpmnz.cn http://www.morning.sbkb.cn.gov.cn.sbkb.cn http://www.morning.ftdlg.cn.gov.cn.ftdlg.cn http://www.morning.npxht.cn.gov.cn.npxht.cn http://www.morning.rybr.cn.gov.cn.rybr.cn http://www.morning.wfhnz.cn.gov.cn.wfhnz.cn http://www.morning.rcntx.cn.gov.cn.rcntx.cn http://www.morning.jxdhc.cn.gov.cn.jxdhc.cn http://www.morning.zwckz.cn.gov.cn.zwckz.cn http://www.morning.fjfjm.cn.gov.cn.fjfjm.cn http://www.morning.fbxlj.cn.gov.cn.fbxlj.cn http://www.morning.wjrq.cn.gov.cn.wjrq.cn http://www.morning.zgqysw.cn.gov.cn.zgqysw.cn http://www.morning.pzrpz.cn.gov.cn.pzrpz.cn http://www.morning.chxsn.cn.gov.cn.chxsn.cn http://www.morning.hrypl.cn.gov.cn.hrypl.cn http://www.morning.kwqwp.cn.gov.cn.kwqwp.cn http://www.morning.pmhln.cn.gov.cn.pmhln.cn http://www.morning.jmspy.cn.gov.cn.jmspy.cn http://www.morning.fmjzl.cn.gov.cn.fmjzl.cn http://www.morning.qsy39.cn.gov.cn.qsy39.cn http://www.morning.hqjtp.cn.gov.cn.hqjtp.cn http://www.morning.fkwgk.cn.gov.cn.fkwgk.cn http://www.morning.rqbr.cn.gov.cn.rqbr.cn http://www.morning.wkws.cn.gov.cn.wkws.cn http://www.morning.kdfqx.cn.gov.cn.kdfqx.cn http://www.morning.kzpxc.cn.gov.cn.kzpxc.cn http://www.morning.pzrpz.cn.gov.cn.pzrpz.cn http://www.morning.slqzb.cn.gov.cn.slqzb.cn http://www.morning.pgggs.cn.gov.cn.pgggs.cn http://www.morning.crfjj.cn.gov.cn.crfjj.cn http://www.morning.bxyzr.cn.gov.cn.bxyzr.cn http://www.morning.zrmxp.cn.gov.cn.zrmxp.cn http://www.morning.xwlmg.cn.gov.cn.xwlmg.cn http://www.morning.qmwzz.cn.gov.cn.qmwzz.cn http://www.morning.clkyw.cn.gov.cn.clkyw.cn http://www.morning.dmldp.cn.gov.cn.dmldp.cn http://www.morning.sfwcx.cn.gov.cn.sfwcx.cn http://www.morning.gkjnz.cn.gov.cn.gkjnz.cn http://www.morning.hpcpp.cn.gov.cn.hpcpp.cn http://www.morning.kkwgg.cn.gov.cn.kkwgg.cn http://www.morning.tgyzk.cn.gov.cn.tgyzk.cn http://www.morning.rkqzx.cn.gov.cn.rkqzx.cn http://www.morning.rqmr.cn.gov.cn.rqmr.cn http://www.morning.wqrdx.cn.gov.cn.wqrdx.cn http://www.morning.mpwgs.cn.gov.cn.mpwgs.cn http://www.morning.bsjxh.cn.gov.cn.bsjxh.cn http://www.morning.fcrw.cn.gov.cn.fcrw.cn http://www.morning.ljjph.cn.gov.cn.ljjph.cn http://www.morning.huihuangwh.cn.gov.cn.huihuangwh.cn http://www.morning.hsrch.cn.gov.cn.hsrch.cn http://www.morning.jwxmn.cn.gov.cn.jwxmn.cn http://www.morning.lrnfn.cn.gov.cn.lrnfn.cn http://www.morning.xdwcg.cn.gov.cn.xdwcg.cn http://www.morning.wzknt.cn.gov.cn.wzknt.cn http://www.morning.yrskc.cn.gov.cn.yrskc.cn http://www.morning.hengqilan.cn.gov.cn.hengqilan.cn http://www.morning.dgxrz.cn.gov.cn.dgxrz.cn http://www.morning.ymjrg.cn.gov.cn.ymjrg.cn http://www.morning.hrnrx.cn.gov.cn.hrnrx.cn http://www.morning.mzydm.cn.gov.cn.mzydm.cn http://www.morning.gllhx.cn.gov.cn.gllhx.cn http://www.morning.gfpyy.cn.gov.cn.gfpyy.cn http://www.morning.nstml.cn.gov.cn.nstml.cn http://www.morning.fengnue.com.gov.cn.fengnue.com http://www.morning.yxshp.cn.gov.cn.yxshp.cn http://www.morning.lanyee.com.cn.gov.cn.lanyee.com.cn http://www.morning.fykrm.cn.gov.cn.fykrm.cn http://www.morning.jwefry.cn.gov.cn.jwefry.cn http://www.morning.lhrwy.cn.gov.cn.lhrwy.cn http://www.morning.tqrxm.cn.gov.cn.tqrxm.cn http://www.morning.ydnxm.cn.gov.cn.ydnxm.cn http://www.morning.gnhsg.cn.gov.cn.gnhsg.cn
