设计模式之工厂模式&代理模式

1.什么是工厂模式

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

2.工厂模式的好处

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

3.工厂模式的实现方式

 1）简单工厂模式：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）(其实这并不是27种设计模式里的，最大的缺点工厂职责过重)

public interface Car {
	public void run();
}

public class Audi implements Car {
	public void run() {
		System.out.println(\"我是奥迪汽车..\");
	}
}
public class Benz 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 Audi();
		}
		if(name.equals(\"奔驰\")){
			return new Benz();
		}
		return null;
	}
}
public class Client01 {

	public static void main(String[] args) {
		Car audi =CarFactory.createCar(\"奥迪\");
		Car benz =CarFactory.createCar(\"奔驰\");
		audi.run();
		benz.run();
	}

}

 2）工厂方法模式：用来生产同一等级结构中的固定产品。（支持拓展增加产品）

public interface Car {
	public void run();
}

public class Audi implements Car {
	public void run() {
		System.out.println(\"我是奥迪汽车..\");
	}
}
public class Beanz implements Car {
	public void run() {
		System.out.println(\"我是奔驰汽车...\");
	}
}
public class BenzFactory implements CarFactory {
	public Car createCar() {

		return new Benz();
	}
}
public class AudiFactory implements CarFactory {
	public Car createCar() {
	
		return new Audi();
	}
}
public class Client {
	public static void main(String[] args) {
		Car audi = new AudiFactory().createCar();
		Car benz = new BenzFactory().createCar();
		audi.run();
		benz.run();
	}
}

 3）抽象工厂模式：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

//发动机
public interface Engine {

	void run();

	void start();
}

class EngineA implements Engine {

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

	public void start() {
		 System.out.println(\"启动快,自动档\");
	}

}

class EngineB implements Engine {

	public void run() {
      System.out.println(\"转的慢!\");
	}

	public void start() {
		 System.out.println(\"启动快,手动档\");
	}

}

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

 class ChairA implements Chair{

	public void run() {
		System.out.println(\"可以自动加热!\");
	}
	
}
 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();

	}
	
}

4.代理设计模式

通过代理控制对象的访问，可以详细访问某个对象的方法，在这个方法调用之前或者之后处理，或调用后处理。即（AOP微实现）

5.代理设计模式的分类

 1）静态代理模拟dao层通过静态代理实现事务的开启与提交
      1.创建一个dao层接口
 

package com.test.proxy;

public interface IUserDao {

	public void add();
}

     
       2.创建一个实现类（被代理对象）

package com.test.proxy;

public class UserDaoImpl implements IUserDao{

    @Override
    public void add() {
        System.out.println(\"执行add方法\");
    }

}

          3.创建一个代理类

package com.test.proxy;

public class UserDaoProxy implements IUserDao{
	
	private IUserDao iUserDao;
	public UserDaoProxy(IUserDao iUserDao) {
		this.iUserDao = iUserDao;
	}

	@Override
	public void add() {
		System.out.println(\"开启事务\");
		iUserDao.add();
		System.out.println(\"提交事务\");
	}

}

         4.测试运行

package com.test.proxy;

public class TestRun {

	public static void main(String[] args) {
		IUserDao userDao = new UserDaoImpl(); 
		UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
		userDaoProxy.add();
		
	}
}

  2）动态代理

 2.1）什么是动态代理

 2.1.1）代理对象，不需要实现接口

 2.1.2）代理对象的生成，是利用JDK的API，动态的在内存中构建对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

 2.1.3）动态代理也叫做JDK代理/接口代理。

 2.2）JDK动态代理（底层使用的反射）

package com.test.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//每次生成动态代理类对象时，实现了InvocationHandler接口的调用处理器对象
public class InvocationHandlerImpl implements InvocationHandler{
	//目标代理对象
	private   target;
	
	public InvocationHandlerImpl(  target) {
		this.target = target;
	}

	@Override
	public   invoke(  proxy, Method method,  [] args) throws Throwable {
		System.out.println(\"开启事务\");
		  invoke = method.invoke(target, args);
		System.out.println(\"提交事务\");
		return invoke;
	}
	
	//测试
	public static void main(String[] args) {
		IUserDao iUserDao = new UserDaoImpl();
		InvocationHandlerImpl handlerImpl = new InvocationHandlerImpl(iUserDao);
		ClassLoader classLoader = iUserDao.getClass().getClassLoader();
		Class<?>[] interfaces = iUserDao.getClass().getInterfaces();
		//调用动态代理实例
		IUserDao userdao = (IUserDao) Proxy.newProxyInstance(classLoader, interfaces, handlerImpl);
		userdao.add();
	}

}

2.3）CGLIB动态代理 （底层使用asm字节码技术，优点是不需要被代理对象拥有接口）

package com.test.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxy implements MethodInterceptor{
	private   target;
	
	public   getInstance(  target) {
		this.target = target;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(target.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}

	public   intercept(  arg0, Method method,  [] args, MethodProxy proxy) throws Throwable {
		System.out.println(\"开启事务\");
		proxy.invoke(target, args);
		System.out.println(\"提交事务\");
		return null;
	}
	
	//测试
	public static void main(String[] args) {
		CglibProxy cglibProxy = new CglibProxy();
		UserDaoImpl userDaoImpl = (UserDaoImpl) cglibProxy.getInstance(new UserDaoImpl());
		userDaoImpl.add();
	}

}