工厂设计模式和模板设计模式及Proxy动态代理的简述

工厂设计模式

这里简单描述工厂方法模式和简单工厂模式这两种工厂模式。
工厂方法模式
概述
工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
优点
客户端不需要在负责对象的创建，直接从具体的实现工厂类中获取对象。
如果有新的对象增加，只需要增加一个具体的类和具体的实现工厂类即可，不影响已有的代码
后期维护容易，增强了系统的扩展性。
缺点
需要额外的编写代码，增加了工作量。

抽象工厂类

//抽象工厂类
public abstract class AnimalFactory {
	public abstract Animal createAnimal();
	
	
}

具体实现工厂类

//具体实现工厂类
public class DogFactory  extends  AnimalFactory{

	@Override
	public Animal createAnimal() {
		
		return new  Dog("小狗", "白色");
	}

}

工厂方法模式使用

public class 工厂方法模式 {

	public static void main(String[] args) {
		
		AnimalFactory dogFactory=new  DogFactory();
		Animal  animal=dogFactory.createAnimal();
		System.out.println(animal);
	}

}

简单工厂模式
概述
又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。
优点
客户端不需要在负责对象的创建，直接从具体的实现工厂类中获取对象。
缺点
这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

具体实现工厂类

//具体实现工厂类
public class AnimalFactory2 {

	public  static  Animal  createDog()
	{
		return  new  Dog("小狗", "黄色");
	}
}

简单工厂模式使用

public class 简单工厂模式 {

	public static void main(String[] args) {
		//类名.静态方法生成对象
		Animal   animal=AnimalFactory2.createDog();
		System.out.println(animal);

	}

}

模版设计模式

概述
模版设计模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现

计时算法骨架

abstract class TimeTemplate{
	//获取代码执行时间
	public long getScheduleTime(){
	    //获取当前时间
		long start = System.currentTimeMillis();
		//测试代码
		code();
		//获取结束时间
		long end = System.currentTimeMillis();
		long delta = end - start;//计算时间差 毫秒
		return delta;
	}
	//测试代码交给实现类(子类) 实现
	public abstract void code();
}

实现类

class Test1 extends TimeTemplate{

	@Override
	public void code() {
           for(int i=0;i<100000;i++){
			System.out.println("测试算法");
		}
	}
	
}

模版设计模式使用

public class Demo01 {
	public static void main(String[] args) {
		//模版(Template)设计模式
		System.out.println(new Test1().getScheduleTime());
	}
}

动态代理

概述
代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。
举例：春节回家买票让人代买
两种实现方式：
jdk 的动态代理Proxy: Proxy需要接口和实现类
cglib字节码增强 : cglib字节码增强只需要实现类。

jdk 的动态代理Proxy简述
a: 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口通过使用这个类和接口就可以生成动态代理对象。

b: InvocationHandler API中简介是：
Each proxy instance has an associated invocation handler.When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the {@code invoke} method of its invocation handler.
大概意思是每个动态代理类都要实现InvocationHandler接口，并且关联到一个handler，通过代理对象调用时，这个接口的方法调用就会转接到该handler的invoke方法进行调用。

c: Proxy 通过public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)创建代理对象
// ClassLoader loader：被代理实现类的加载器
// Class<?>[] interfaces：被代理实现类的接口
// InvocationHandler h：代理的调用处理者

d: InvocationHandler的public Object invoke(Object proxy, Method method, Object[] args)方法会拦截方法的调用
// Object proxy:被代理的对象
// Method method:要调用的方法
// Object args[]:方法调用时所需要的参数

接口代码：

//接口
interface UserService {
	// 注册用户
	public void registerUser();

	// 删除用户
	public void deleteUser();
}

实现类代码：

//实现类
class UserServiceImpl implements UserService {

	@Override
	public void registerUser() {

		System.out.println("注册一个用户");

	}

	@Override
	public void deleteUser() {

		System.out.println("删除一个用户");

	}
}

测试类代码：

public class Demo01 {

	public static void main(String[] args) {

		// 1.创建对象
		UserServiceImpl usi = new UserServiceImpl();
		

		// 2.创建代理对象
		// UserServiceImpl类的加载器：usi.getClass().getClassLoader()
		// UserServiceImpl类的接口：usi.getClass().getInterfaces()
		// 代理的调用处理者： new InvocationHandler(){}
		UserService proxy = (UserService) Proxy.newProxyInstance(usi.getClass().getClassLoader(),
				usi.getClass().getInterfaces(), new InvocationHandler() {
					// Object proxy:被代理的对象
					// Method method:要调用的方法
                    // Object args[]:方法调用时所需要的参数
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 显示被拦截方法
						System.out.println(method);
						// 在方法前添加
						System.out.println("权限检验...");
						// 拦截了所有方法
					   Object obj=  method.invoke(usi, args);
						// 在方法后添加
						System.out.println("日志记录");
						//这里也可以返回null
						return obj;
					}
				});
        //使用代理对象
		proxy.deleteUser();
		proxy.registerUser();
	}
}

测试结果：