设计模式专题之简单工厂&工厂方法&抽象工厂&静态代理&动态代理

1. 工厂模式

1.1 什么是工厂模式

实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式

1.2 工厂模式好处

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。
利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

1.3 工厂模式分类

1.3.1 简单工厂模式

简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。

public interface Car {
	public void run();
}

public class AoDi implements Car {
	public void run() {
		System.out.println("我是奥迪汽车..");
	}
}

public class JiLi implements Car {

	public void run() {
		System.out.println("我是吉利汽车...");
	}
}

public class CarFactory {

	 public static Car createCar(String name) {
		if (StringUtils.isEmpty(name)) {
             return null;
		}
		if(name.equals("奥迪")){
			return new AoDi();
		}
		if(name.equals("吉利")){
			return new JiLi();
		}
		return null;
	}
}

public class Client01 {

	public static void main(String[] args) {
		Car aodi  =CarFactory.createCar("奥迪");
		Car jili  =CarFactory.createCar("吉利");
		aodi.run();
		jili.run();
	}

}

简单工厂的优点/缺点
优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

1.3.2 工厂方法模式

什么是工厂方法模式

工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

public interface Car {
	public void run();
}

public class AoDi implements Car {
	public void run() {
		System.out.println("我是奥迪汽车..");
	}
}

public class JiLi implements Car {

	public void run() {
		System.out.println("我是吉利汽车...");
	}
}

public interface CarFactory {
    public Car createCar();   
}

public class JiLiFactory implements CarFactory {

	public Car createCar() {

		return new JiLi();
	}

}

public class AoDiFactory implements CarFactory {

	public Car createCar() {
	
		return new AoDi();
	}
}

public class Client {

	public static void main(String[] args) {
		Car aodi = new AoDiFactory().createCar();
		Car jili = new JiLiFactory().createCar();
		aodi.run();
		jili.run();
	}

}

1.3.3 抽象工厂模式

什么是抽象工厂模式
抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。

发动机接口

//发动机
public interface Engine {

	void run();

	void start();
}

发动机A

class EngineA implements Engine {

	public void run() {	
      System.out.println("低配发动机!");
	}

	public void start() {
		 System.out.println("低配");
	}

}

发动机B

class EngineB implements Engine {

	public void run() {
      System.out.println("高配，转的快!");
	}

	public void start() {
		 System.out.println("高配");
	}

}

座椅

//座椅
public interface Chair {
	   void run();
}

座椅A

 class ChairA implements Chair{

	public void run() {
		System.out.println("低配");
	}
	
}

座椅B

 class ChairB implements Chair{

	public void run() {
		System.out.println("高配");
	}
	
}

汽车工厂接口

public interface CarFactory {
	// 创建发动机
	Engine createEngine();
	// 创建座椅
	Chair createChair();
}

吉利工厂

public class JiLiFactory implements CarFactory  {

	public Engine createEngine() {
	
		return new EngineA();
	}

	public Chair createChair() {
		
		return new ChairA();
	}

}

public class Client002 {
	 public static void main(String[] args) {
		CarFactory carFactory=new JiLiFactory();
		Engine engine=carFactory.createEngine();
		engine.run();
		engine.start();
	}
}

其中Char和Engine是两个产品族，CharA和EngineA是同一个产品等级（都是低配），CharB和EngineB是同一个产品等级（都是高配），

1.3.4 简单工厂、工厂方法、抽象工厂之小结、区别

1. 简单工厂顾明思议，实现比较简单，用来生产同一等级结构中的任意产品,只需要传入一个特定参数即可，不用知道具体的工厂实现类名，缺点就是违背了开闭原则,所以可以说不支持拓展增加产品。
2. 工厂方法和抽象工厂，遵守开闭原则，解耦了类关系。但是，扩展比较复杂，需要增加一系列的类。
3. 需要注意，工厂方法和抽象工厂的区别就在于，抽象工厂关注于某一个产品族（可以增加），当产品对象之间是有关联关系的一个产品族时用这种方式，而工厂方法没有产品族的概念，只是用来生产同一等级结构中的固定产品。

2. 代理模式

2.1 什么是代理模式

通过代理控制对象的访问,可以详细访问某个对象的方法，在这个方法调用处理，或调用后处理。既(AOP微实现) ,AOP核心技术面向切面编程。

2.2 代理模式应用场景

SpringAOP、事物原理、日志打印、权限控制、远程调用、安全代理 可以隐蔽真实角色

2.3 代理的分类

静态代理(静态定义代理类)
动态代理(动态生成代理类)
Jdk自带动态代理
Cglib 、javaassist（字节码操作库）

2.4 静态代理

什么是静态代理：
由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

静态代理代码

public interface IUserDao {
	void save();
}

public class UserDao implements IUserDao {
	public void save() {
		System.out.println("已经保存数据...");
	}
}

代理类

public class UserDaoProxy implements IUserDao {
	private IUserDao target;

	public UserDaoProxy(IUserDao iuserDao) {
		this.target = iuserDao;
	}

	public void save() {
		System.out.println("开启事物...");
		target.save();
		System.out.println("关闭事物...");
	}

}

这里可以看到代理类必须要实现被代理类的接口，这是非常不利于扩展的

2.5 动态代理

什么是动态代理

1. 代理对象,不需要实现接口
2. 代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3. 动态代理也叫做:JDK代理,接口代理

2.5.1 JDK动态代理

原理：是根据类加载器和接口创建代理类（此代理类是接口的实现类，所以必须使用接口 面向接口生成代理，位于java.lang.reflect包下）

实现方式： 通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型Constructor constructor = clazz.getConstructor(newClass[]InvocationHandler.class});
通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

缺点：jdk动态代理，必须是面向接口，目标业务类必须实现接口

// 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象 
public class InvocationHandlerImpl implements InvocationHandler {
	private Object target;// 这其实业务实现类对象，用来调用具体的业务方法
	// 通过构造函数传入目标对象
	public InvocationHandlerImpl(Object target) {
		this.target = target;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object result = null;
		System.out.println("调用开始处理");
		result = method.invoke(target, args);
		System.out.println("调用结束处理");
		return result;
	}

	public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException,
			IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		// 被代理对象
		IUserDao userDao = new UserDao();
		InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDao);
		ClassLoader loader = userDao.getClass().getClassLoader();
		Class<?>[] interfaces = userDao.getClass().getInterfaces();
		// 主要装载器、一组接口及调用处理动态代理实例
		IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
		newProxyInstance.save();
	}

}

2.5.2 CGLIB动态代理

原理：利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

什么是CGLIB动态代理
使用cglib[Code Generation Library]实现动态代理，并不要求委托类必须实现接口，底层采用asm字节码生成框架生成代理类的字节码

CGLIB动态代理相关代码：

public class CglibProxy implements MethodInterceptor {
	private Object targetObject;
	// 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
	public Object getInstance(Object target) {
		// 设置需要创建子类的类
		this.targetObject = target;
		//生成目标代理对象虚拟的子类
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(target.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}

	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("开启事物");
		Object result = proxy.invoke(targetObject, args);
		System.out.println("关闭事物");
		// 返回代理对象
		return result;	
	}
	public static void main(String[] args) {
		CglibProxy cglibProxy = new CglibProxy();
		UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());	
		userDao.save();
	}
}

2.5.3 CGLIB动态代理与JDK动态区别

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

Spring中：
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

JDK动态代理只能对实现了接口的类生成代理，而不能针对类 。
CGLIB是针对类实现代理，主要是对指定的类生成一个虚拟子类子类，覆盖其中的方法 。
因为是继承，所以目标代理类或方法最好不要声明成final ，final可以阻止继承和多态，否则会出现如下错误: