Java设计模式
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。
使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。
Java设计模式分为三大类
-
创建型模式:对象实例化的模式,创建型模式用于解耦对象的实例化过程。
-
结构型模式:把类或对象结合在一起形成一个更大的结构。
-
行为型模式:类和对象如何交互,及划分责任和算法。
一、设计模式的六大原则
1、开闭原则(Open Close Principle)
开闭原则的意思是:对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。
2、里氏代换原则(Liskov Substitution Principle)
里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。
3、依赖倒转原则(Dependence Inversion Principle)
这个原则是开闭原则的基础,具体内容:针对接口编程,依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)
这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。它还有另外一个意思是:降低类之间的耦合度。由此可见,其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想,它强调降低依赖,降低耦合。
5、迪米特法则,又称最少知道原则(Demeter Principle)
最少知道原则是指:一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)
合成复用原则是指:尽量使用合成/聚合的方式,而不是使用继承。
二、创建型模式
谈谈你对创建型模式的理解
1.单例设计模式:
一个类只允许创建一个对象(或者实例),那这个类就是一个单例类,这种设计模式就叫做单例设计模式
单例模式是创建对象的一种特殊方式,程序从始至终都只创建一个对象叫单例
1.1饿汉式单例
饿汉式的实现方式比较简单。在类加载的时候,instance 静态实例就已经创建并初始化好了,所以,instance 实例的创建过程是线程安全的。不过,这样的实现方式不支持延迟加载(在真正用到 的时候,再创建实例)。
缺点:因为不支持延迟加载,如果实例占用资源多(比如占用内存多)或初始化耗时长(比如需要加载各种配置文件),提前初始化实例是一种浪费资源的行为。
public class Student {
//1、 饿汉式单例模式, 在类加载时创建一个对象
private static Student student = new Student();
// 2 构造器私有化
private Student(){
}
// 3 提供返回类对象的静态方法
public static Student getInstance(){
if(student !=null){
return student;
}
return null;
}
}
1.2懒汉式单例
在真正需要使用对象的时候才会去创建该对象;
public class Lazy_Man {
private static Lazy_Man lazyMan=null;
private Lazy_Man(){}
public static Lazy_Man getInstance(){
if (lazyMan==null){
lazyMan =new Lazy_Man();
}
return lazyMan;
}
}
1.3双重检测锁
public class Lazy_Man2 {
private volatile static Lazy_Man2 lazyMan=null;
private Lazy_Man2(){}
public static Lazy_Man2 getInstance(){
if(lazyMan==null){
synchronized (Lazy_Man2.class){
if (lazyMan==null){
//1.分配内存空间2.执行构造方法,实例化对象3.把这个对象赋值给这个空间
//如果不加volatile会执行重排序13 2
lazyMan =new Lazy_Man2();
}
}
}
return lazyMan;
}
}
2.说说你在哪些框架中看到了单例的设计
1.Spring中的Bean对象,默认是单例模式
⒉.相关的工厂对象都是单例,比如:MyBatis中的SqlSessionFactory,Spring中的BeanFactory.
3.保存相关配置信息的都是单例,比如:MyBatis中的Configuration对象,SpringBoot中的各个XXAutoConfiguration对象等
4.应用程序的日志应用,一般都会通过单例来实现
5.数据库连接池的设计也是单例模式
2.工厂模式
创建对象的过程不再由当前类实例化,而是由工厂类完成,在工厂类中只需要告知对象类型即可。工厂模式中必须依赖接口
2.1简单工厂模式
2.2工厂方法模式
工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中,支持增加任意产品。
总而言之:一个接口被多实现
//创建一个接口:
public interface Shape {
void draw();
}
//创建实现接口的实体类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
//创建一个工厂,生成基于给定信息的实体类的对象。
public class ShapeFactory {
//创建一个工厂,生成基于给定信息的实体类的对象。
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
//使用该工厂,通过传递类型信息来获取实体类的对象。
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory=new ShapeFactory();
//获取 Circle 的对象,并调用它的 draw 方法
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取 Rectangle 的对象,并调用它的 draw 方法
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取 Square 的对象,并调用它的 draw 方法
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
}
}
3.抽象工厂模式
抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
//为 Color 和 Shape 对象创建抽象类来获取工厂。
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape);
}
//创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){ return null;}
@Override
public Color getColor(String color) {
if(color == null){ return null;}
if(color.equalsIgnoreCase("RED")){ return new Red();
} else if(color.equalsIgnoreCase("GREEN")){return new Green();}
return null;
}
}
//创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
} else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
//使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("GREEN");
//调用 Green 的 fill 方法
color2.fill();
总结:对于简单工厂,工厂方法模式和抽象工厂的区别和用途
小结:
★工厂模式中,重要的是工厂类,而不是产品类。产品类可以是多种形式,多层继承或者是单个类都是可以的。但要明确的,工厂模式的接口只会返回一种类型的实例,这是在设计产品类的时候需要注意的,最好是有父类或者共同实现的接口。
★使用工厂模式,返回的实例一定是工厂创建的,而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的,返回由工厂创建好的实例也是可以的。
区别:
1、对于简单工厂,用于生产同一结构中的任意产品,对于新增产品不适用。
2、对于工厂方法,在简单工厂的基础上,生产同一等级结构中笃定产品,可以支持新增产品。
3、抽象工厂,用于生产不同种类(品牌)的相同类型(迷你,SUV),对于新增品牌可以,不支持新增类型
4.建造者模式
用来解决复杂对象创建的一种设计模式
建造者模式和工厂模式的区别:
- 建造者模式更加注重方法的调用顺序,工厂模式注重于创建对象。
- 创建对象的力度不同,建造者模式创建复杂的对象,由各种复杂的部件组成,工厂模式创建出来的都一样。
- 关注点不一样,工厂模式只需要把对象创建出来就行了,而建造者模式不仅要创建出这个对象,还要知道这个对象由哪些部分组成。
- 建造者模式根据建造过程中的顺序不一样,最终的对象部件组成也不一样。
5.原型模式
批量对象的创建
5.1浅克隆
被复制对象的所有变是都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。0bject类提供的方法clone=只是拷贝本对象=,=其对象内部的数组、引用对象等都不拷贝=,还是指向原生对象的内部元素地址.
被克隆的对象必须Cloneable,Serializable这两个接口;
浅克隆的问题:虽然产生了两个完全不同的对象,但是被复制的对象的所有变是都含有与原来的对象相同的值,而所有的对其他对象的引用都仍然指向原来的对象。
5.2深克隆
被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍。
三、结构型模式
1.代理模式
1.1代理模式的作用
代理模式的作用是通过代理对象来增强目标对象的功能,利用AOP的切面思想。
1.2代理模式的实现方式
代理模式的实现方式有三种:静态代理,动态代理(JDK动态代理和CGLIB动态代理)
1.2.1静态代理
静态代理需要代理类与目标类有一样的继承父类和实现接口
public interface UserDao {
public void addUser();
public void deleteUser();
}
public class DbUser implements UserDao {
@Override
public void addUser() {
System.out.println("添加用户操作");
}
@Override
public void deleteUser() {
System.out.println("删除用户操作");
}
}
public class StaticProxyUser implements UserDao {
private DbUser target;
public StaticProxyUser(DbUser dbUser) {
target = dbUser;
}
@Override
public void addUser() {
System.out.println("添加前的操作");
target.addUser();
System.out.println("添加后的操作");
}
@Override
public void deleteUser() {
System.out.println("删除前的操作");
target.deleteUser();
System.out.println("删除后的操作");
}
}
public class MyTest {
@Test
public void demo() {
StaticProxyUser staticProxyUser = new StaticProxyUser(new DbUser());
staticProxyUser.addUser();
staticProxyUser.deleteUser();
}
}
静态代理总结:
1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.
1.2.2 JDK动态代理
动态代理不用实现目标类的接口,不会出现大量代理类的现象,一般情况下创建一个代理类就可以了。
动态代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
动态代理也叫做:JDK代理,接口代理
动态代理需要使用newProxyInstance方法,该方法结构为static Object newProxyInstance(ClassLoader loader, Class<?>] interfaces,InvocationHandler h ),可以看到该方法需要三个参数
参数1:ClassLoader 需要一个类加载器,Java中常用的类加载器有三种类型
启动类加载器(Bootstrap ClassLoader):
这个类加载器负责将\lib目录下的类库加载到虚拟机内存中,用来加载java的核心库,此类加载器并不继承于java.lang.ClassLoader,不能被java程序直接调用,代码是使用C++编写的.是虚拟机自身的一部分.
扩展类加载器(Extendsion ClassLoader):
这个类加载器负责加载\lib\ext目录下的类库,用来加载java的扩展库,开发者可以直接使用这个类加载器.
应用程序类加载器(Application ClassLoader):
这个类加载器负责加载用户类路径(CLASSPATH)下的类库,一般我们编写的java类都是由这个类加载器加载,这个类加载器是CLassLoader中的getSystemClassLoader()方法的返回值,所以也称为系统类加载器.一般情况下这就是系统默认的类加载器.
除此之外,我们还可以加入自己定义的类加载器,以满足特殊的需求,需要继承java.lang.ClassLoader类.
参数2:Class <?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
参数3:InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
//接口
public interface UserService {
void addUser();
void updateUser();
void delUser();
}
//实现接口
public class UserServiceImpl implements UserService {
@Override
public void addUser() {
System.out.println("添加用户");
}
@Override
public void updateUser() {
System.out.println("更新用户");
}
@Override
public void delUser() {
System.out.println("删除用户");
}
}
// 代理类:
public class ProxyFactory {
private Object target;
public ProxyFactory(Object object){
this.target=object;
}
public Object getProxyInstance(){
return Proxy.newProxyInstance(ProxyFactory.class.getClassLoader(),//类加载器
target.getClass().getInterfaces(), //目标对象实现的相关接口
new InvocationHandler() {//代理对象的回调方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始事务2");
Object invoke = method.invoke(target, args);
System.out.println("提交事务2");
return invoke;
}
});
}
}
//测试
public class Mtytest {
public static void main(String[] args) {
UserService userService=new UserServiceImpl();
UserService instance = (UserService) new ProxyFactory(userService).getProxyInstance();
instance.addUser();
}
}
笔试题:写一个 ArrayList 的动态代理类
public class ProxyTest {
//写一个 ArrayList 的动态代理类
public static void main(String[] args) {
final List<String> list=new ArrayList<>();
List<String> proxyInstance = (List<String>) Proxy.newProxyInstance(list.getClass().getClassLoader(), list.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(list, args);
return invoke;
}
});
proxyInstance.add("你好");
System.out.println(list);
}
}
1.2.3CGLIB代理
Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.
DK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.
//接口和目标类同上
public class MyBeanFactory {
//cglib代理
public static UserService createUserService(){
//目标类
final UserService userService = new UserServiceImpl();
/**
* 代理类
* 回掉函数中的intercept同jdk动态代理的invoke方法
* 4个参数,前三个同jdk动态代理的参数
* 第四个参数:methodProxy是目标类的方法的代理
*
*/
//1.1核心类
Enhancer enhancer = new Enhancer();
//1.2确定父类
enhancer.setSuperclass(UserService.class);
//1.3设置回掉函数
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("执行前");
Object invoke = method.invoke(userService, objects);
System.out.println("执行后");
return invoke;
}
});
UserService userService1 = (UserService) enhancer.create();
return userService1;
}
}
面试题一:JDK动态代理和CGLIB动态代理区别?
① JDK 动态代理本质上是实现了被代理对象的接口,而 CGLib 本质上是继承了被代理对象,覆盖其中的方法。
② JDK 动态代理只能对实现了接口的类生成代理,CGLib 则没有这个限制。但是 CGLib 因为使用继承实现,所以 CGLib 所以无法对 final 类、private 方法和 static方法进行代理。
③ JDK 动态代理是 JDK 里自带的,CGLib 动态代理需要引入第三方的 jar 包。
④ 在调用代理方法上,JDK动态代理是通过反射机制调用,CGLib 是通过 FastClass 机制直接调用。(看过一篇文章,介绍说 FastClass 简单的理解,就是使用一个 index 下标作为入参,可以直接定位到要调用的方法直接,并进行调用)
在性能上,JDK1.7 之前,由于使用了 FastClass 机制,CGLib 在执行效率上比 JDK 快,但是随着 JDK 动态代理的不断优化,从 JDK 1.7 开始,JDK 动态代理已经明显比 CGLib 更快了。
2.适配器模式
适配器模式的作用是把两个不兼容的类/对象/接口通过适配器能够连接起来工作。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MbmgJZOs-1667921061561)(C:\Users\xhd\AppData\Roaming\Typora\typora-user-images\image-20220912192231507.png)]
2.1类适配器模式
从下面的结构图可以看出,Adaptee类并没有method2()方法,而客户端则期待这个方法。为使客户端能够使用Adaptee类,我们把Adaptee与Target衔接起来。Adapter与Adaptee是继承关系,这决定了这是一个类适配器模式
//源:
public class Adaptee {
public void method1() {
System.out.println("老的方法实现");
}
}
//目标:
public interface Target {
void method1();
void method2();
}
//适配器:
public class Adapter extends Adaptee implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void method2() {
System.out.println("method2" + "新的方法");
}
}
2.2对象适配器模式
从下面的结构图可以看出,Adaptee类并没有method2()方法,而客户端则期待这个方法。与类适配器模式一样,为使客户端能够使用Adaptee类,我们把Adaptee与Target衔接起来。但这里我们不继承Adaptee,而是把Adaptee封装进Adapter里。这里Adaptee与Adapter是组合关系。
//Target和Adaptee和上面的类适配器一样
public class Adapter1 implements Target {
private Adaptee adaptee;
public Adapter1(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void method1() {
adaptee.method1();
}
@Override
public void method2() {
System.out.println("method2" + "新的方法");
}
}
类适配器与对象适配器的区别
类适配器使用的是继承的方式,直接继承了Adaptee,所以无法对Adaptee的子类进行适配。
对象适配器使用的是组合的方式,·所以Adaptee及其子孙类都可以被适配。另外,对象适配器对于增加一些新行为非常方便,而且新增加的行为同时适用于所有的源。
基于组合/聚合优于继承的原则,使用对象适配器是更好的选择。
3.装饰者模式
3.1装饰者模式的作用
允许向一个现有的对象添加新的功能,同时又不改变其结构
装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术,无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系,更加灵活,同时避免类型体系的快速膨胀。
四、行为型模式
1.观察者模式
1.1观察者模式的作用
建立对象与对象之间的依赖关系,一个对象发生改变时,会自动通知其他对象。这个场景中,发生改变的对象被称为观察目标,被通知的对象称为观察者。一个观察目标可以有多个观察者,而这些观察者之间可以没有联系,可以根据需要增加或删除观察者。
public void method2() {
System.out.println(“method2” + “新的方法”);
}
}
**类适配器与对象适配器的区别**
类适配器使用的是继承的方式,直接继承了Adaptee,所以无法对Adaptee的子类进行适配。
对象适配器使用的是组合的方式,·所以Adaptee及其子孙类都可以被适配。另外,对象适配器对于增加一些新行为非常方便,而且新增加的行为同时适用于所有的源。
基于组合/聚合优于继承的原则,使用对象适配器是更好的选择。
### 3.装饰者模式
#### 3.1装饰者模式的作用
允许向一个现有的对象添加新的功能,同时又不改变其结构
装饰者模式又称为包装模式(Wrapper),作用是用来动态的为一个对象增加新的功能。装饰模式是一种用于代替继承的技术,无须通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系,更加灵活,同时避免类型体系的快速膨胀。
## 四、行为型模式
#### 1.观察者模式
##### 1.1观察者模式的作用
建立对象与对象之间的依赖关系,一个对象发生改变时,会自动通知其他对象。这个场景中,发生改变的对象被称为观察目标,被通知的对象称为观察者。一个观察目标可以有多个观察者,而这些观察者之间可以没有联系,可以根据需要增加或删除观察者。
![在这里插入图片描述](https://img-blog.csdnimg.cn/8c7b1aadf4334b0e960697081cd7e6b6.png#pic_center)