一、建造者模式

发生场景

假如有一结果api结果返回值的类Person，其在代码中频繁被使用。如果要使用它，一般的方法是：

public class Main {public static void main(String[] args) {//方法1，使用全量的构造函数Person person1 = new Person("Tom", 28, "Male");//方法2，使用空的构造函数加setter函数赋值Person person2 = new Person();person2.setName("Tom");person2.setAge(28);person2.setGender("Male");}
}//--》产品
class Person {private String name;private int age;private String gender;public Person() {}public Person(String name, int age, String gender) {this.name = name;this.age = age;this.gender = gender;}public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}public void setGender(String gender) {this.gender = gender;}
}

这两种使用方法的弊端有：

（1）方法一：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则构造函数冗长；

（2）方法二：setter冗长；

使用建造者模式优化上述场景

//使用方法--》指导者
Person person = Person.builder().name("Tom")   //相当于setName("Tom"),只是方法名取name.age(28).gender("Male").build();//--》产品
public class Person {private String name;private int age;private String gender;//⑤public Person(String name, int age, String gender) {this.name = name;this.age = age;this.gender = gender;}//①public static PersonBuilder builder() {return new PersonBuilder();}
}// Java 实现--》建造者
public class PersonBuilder {private String name;private int age;private String gender;//②空构造器public PersonBuilder() {}//③然后使用setter方法进行设置public PersonBuilder name(String name) {this.name = name;return this;  //方法返回当前对象的引用。这样可以支持方法链式调用。//通过返回当前对象的引用，可以在一个语句中连续调用对象的方法，而无需每次调用都创建一个新的对象。}public PersonBuilder age(int age) {this.age = age;return this;}public PersonBuilder gender(String gender) {this.gender = gender;return this;}//④public Person build() {return new Person(name, age, gender);}
}

应用案例

Lombok插件的@Builder注解

//使用
Person person = Person.builder().name("Tom").age(28).gender("Male").build();//lombok优化后
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Person {private String name;private int age;private String gender;
}

---

二、代理模式

避免客户端直接访问真实对象，必须通过代理对象访问真实对象。

好处：①在代理对象中限制访问权限（权限校验）；②在代理对象中扩展功能（日志记录）

静态代理

1. 代理对象和真实对象实现了同一个接口，这样代理对象就具有了和真实对象一样的同名方法
2. 代理对象持有真实对象的实例（代理对象构造器输入参数为公共接口，这样可以代理多个实现类）
3. 调用时使用代理对象的方法，在代理对象的方法里再调用真实对象同名方法和增加一些扩展操作

缺点：

• 代理对象的一个接口只服务于一种类型的对象，如果要代理的类很多，势必要为每一种类都进行代理，在程序规模稍大时静态代理代理类就会过多会造成代码混乱
• 2、如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法，增加了代码维护的复杂度。

动态代理

1.JDK 动态代理（反射）——目标对象实现了接口

1. 定义一个接口及其实现类；
2. 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

//公共接口
public interface SmsService {String send(String message);
}//真实对象
public class SmsServiceImpl implements SmsService {public String send(String message) {System.out.println("send message:" + message);return message;}
}//代理对象（自定义 InvocationHandler）
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;public class DebugInvocationHandler implements InvocationHandler {/*** 代理类中的真实对象*/private final Object target;public DebugInvocationHandler(Object target) {this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {//调用方法之前，我们可以添加自己的操作System.out.println("before method " + method.getName());Object result = method.invoke(target, args);//调用方法之后，我们同样可以添加自己的操作System.out.println("after method " + method.getName());return result;}
}//代理对象的工厂类
public class JdkProxyFactory {public static Object getProxy(Object target) {return Proxy.newProxyInstance(              //创建代理对象target.getClass().getClassLoader(), // 目标类的类加载target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler);}
}//实际使用
SmsService smsServiceProxy = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
smsServiceProxy.send("java");

2.CGLIB 动态代理机制（反射+继承）——目标对象没有实现接口

1. 定义一个类；
2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
3. 通过 Enhancer 类的 create()创建代理类；

//真实对象（类和方法都不能是final的，因为CGLIB代理用到了继承）
public class SmsService {public String send(String message) {System.out.println("send message:" + message);return message;}
}//代理对象（自定义 MethodInterceptor）
public class MethodInterceptor implements MethodInterceptor {//被代理对象private Object target;public MethodInterceptor(Object target) {this.target = target;}public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("CGLib商店打广告！");//调用原来方法Object invoke = method.invokeSuper(target, objects);System.out.println("CGLib商店做售后！");return invoke;}
}//代理对象的工厂类
public class CGlibFactoryProxy {public Object createProxy(Object target){this.target = target;//创建代理对象Enhancer enhancer = new Enhancer();//设置父类，以便 CGLIB 去生成该类的子类enhancer.setSuperclass(this.target.getClass());//设置方法回调MethodInterceptor实现,你可以认为是设置增强方法enhancer.setCallback(new MethodInterceptor());//返回代理对象return enhancer.create();}
}//实际使用
CGlibFactoryProxy factoryProxy = new CGlibFactoryProxy();
SmsService smsServiceProxy = (SmsService) factoryProxy.createProxy(new SmsService());
smsServiceProxy.send("java");

3.应用案例

Spring 框架的 AOP 使用了动态代理模式来实现切面编程。通过代理，Spring 能够在目标对象的方法执行前、执行后或抛出异常时插入切面逻辑，而不需要修改原始代码。

• （切点）在哪里切入，也就是权限校验等非业务操作在哪些业务代码中执行。
• （处理时机）在什么时候切入，是业务代码执行前还是执行后。
• （处理内容）切入后做什么事，比如做权限校验、日志记录等。

Joint point：一个方法的执行或者一个异常的处理。

Weaving：织入，就是通过动态代理，在目标对象方法中执行处理内容的过程。

基于AspectJ实现AOP操作

Spring框架一般都是基于AspectJ实现AOP操作。AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

1.基于xml配置文件实现

2.基于注解方式实现（使用，重要）

//切面类
@Aspect
@Component
public class UserProxy {//1.相同切入点抽取@Pointcut(value = "execution(* com.jin.aopanno.User.add(..))")public void pointdemo(){}@Before(value = "pointdemo()")public void before(){System.out.println("before ...");}//2.不同切入点抽取//前置通知（value = 切入点表达式）@Before(value = "execution(* com.jin.aopanno.User.add(..))")public void before(){System.out.println("before ...");}//3.自定义注解@Before("@annotation(com.easychat.annotation.GlobalInterceptor)")public void before(){System.out.println("before ...");}private void checkLogin(Boolean checkAdmin) {}
}//自定义注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface GlobalInterceptor {//校验登录boolean checkLogin() default true;
}