1.工厂模式介绍
考虑使用工厂模式的情况
- 当客户程序不需要知道要使用对象的创建过程。
- 客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。
举例如下,如下代码中有较多种类的面条,常规情况下如果需要面条,则
INoodles lzNoodles = new LzNoodles();
INoodles paoNoodles = new PaoNoodles();
public interface INoodles {
/**
* 描述每种面条啥样的
*/
public abstract void desc();
}
public class LzNoodles implements INoodles {
@Override
public void desc() {
System.out.println("兰州拉面，兰州特色小吃");
}
}
public class PaoNoodles implements INoodles {
@Override
public void desc() {
System.out.println("泡面，程序员必备");
}
}
1.1.1简单工厂模式
简单工厂类,根据传递的标识不同,返回给不同的面条,
INoodles iNoodles = SimpleNoodlesFactory.createNoodles(2); 则返回泡面
/**
* 简单工厂模式
* 一家“简单面馆”（简单工厂类）
*/
public class SimpleNoodlesFactory {
public static final int TYPE_LZ = 1;//兰州拉面
public static final int TYPE_PM = 2;//泡面
public static final int TYPE_GK = 3;//热干面
/**
* 如果生产对象的方法是static的，这种简单工厂也叫做静态工厂
* 如果生产对象的方法不是static的，这种简单工厂也叫做实例工厂
* @param type
* @return
*/
public static INoodles createNoodles(int type) {
switch (type) {
case 1:
return new LzNoodles();
case 2:
return new PaoNoodles();
case 3:
return new ReganNoodles();
default:
return new LzNoodles();
}
}
}
1.1.2工厂方法模式
每种面条有自己对应的工厂类,专门产出此种面条
工厂
public interface INoodlesFactory {
INoodles createNoodles();
}
兰州拉面工厂
public class LzINoodlesFactory implements INoodlesFactory {
@Override
public INoodles createNoodles() {
return new LzNoodles();
}
}
泡面工厂
public class PaoINoodlesFactory implements INoodlesFactory {
@Override
public INoodles createNoodles() {
return new PaoNoodles();
}
}
1.2.单例模式
目的:目的在于让应用的全局只有一个对象存在
实现前提:首先必须保证构造方法的私有化
1.2.1饿汉式
特点:将自身实例化对象设置为一个属性，并用static、final修饰,类在被在jvm加载时变量就立刻实例化,所以称为饿汉模式
public class HungrySingleton {
// 构造方法私有化
private HungrySingleton() {}
// 将自身实例化对象设置为一个属性，并用static、final修饰
private static final HungrySingleton instance = new HungrySingleton();
// 静态方法返回该实例
public static HungrySingleton getInstance() {
return instance;
}
}
1.2.2懒汉式
特点:懒汉式会提供一个静态方法,会判断是否已经存在,如果为空才会返回,由于懒汉式存在线程安全的问题,所以必须加synchronized关键字
public class LazySingleton {
// 将自身实例化对象设置为一个属性，并用static修饰
private static LazySingleton instance;
// 构造方法私有化
private LazySingleton() {}
// 静态方法返回该实例，加synchronized关键字实现同步
public static synchronized LazySingleton getInstance() {
if(instance == null) {
instance = new LazySingleton();
}
return instance;
}
2.JDK动态代理
静态代理回顾
在说动态代理前,先来了解下静态代理,如下interface IRentingHouse,租房业务,对应的实现如下,如果不使用代理,则要完成租房动作,我们一般会直接就这样完成租房动作
IRentingHouse rentingHouse = new RentingHouseImpl();
rentingHouse.rentHosue();
public interface IRentingHouse {
void rentHosue();
}
public class RentingHouseImpl implements IRentingHouse {
@Override
public void rentHosue() {
System.out.println("我要租用一室一厅的房子");
}
}
代理类
public class RentingHouseProxy implements IRentingHouse {
private IRentingHouse rentingHouse;
public RentingHouseProxy(IRentingHouse rentingHouse) {
this.rentingHouse = rentingHouse;
}
@Override
public void rentHosue() {
System.out.println("中介（代理）收取服务费3000元");
rentingHouse.rentHosue();
System.out.println("客户信息卖了3毛钱");
}
}
建立代理类RentHouseProxy,可以将其看做一个中介,他最终也需要完成租房业务,所以也得实现IRentingHouse,中介需要暴露个接口这样才能接收到需求,所以代理类中有声明一个当前接口的属性private IRentingHouse rentingHouse;此属性可以被赋值,构造函数以及set方法赋值皆可,此类中用的有参构造;
而此中介的rentHouse()里,除了完成了rentHous()这个主要需求外,还在前后实现了收取服务费,卖客户信息等拓展业务,实现了功能增强;这就是代理的作用,代理类用法如下
IRentingHouse rentingHouse = new RentingHouseImpl();
RentingHouseProxy rentingHouseProxy = new RentingHouseProxy(rentingHouse);
rentingHouseProxy.rentHosue();
对于示例中这种,要实现的业务需求,有一个实际对应存在的proxy java类,这种就称为静态代理,如果有其他业务则有另外一个与之对应的代理类.
而动态代理与静态代理最大的差别就是,不像静态代理这样有这么多的代理类,不需要为每个业务都去建立对应的类
2.1JDK动态代理
JDK底层通过反射技术动态生成代理对象,而不用建立对应的代理类
生成代理对象的newProxyInstance有三个参数
ClassLoader loader:类加载器,此处好获取;委托对象.getClass().getClassLoader()即可
Class<?>[] interfaces:指的委托对象所实现的接口;委托对象.getClass().getInterfaces();
InvocationHandler h:增强的逻辑写在这个里面
newProxyInstance源码如下
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) {
Objects.requireNonNull(h);
final Class<?> caller = System.getSecurityManager() == null
? null
: Reflection.getCallerClass();
/*
* Look up or generate the designated proxy class and its constructor.
*/
Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
return newProxyInstance(caller, cons, h);
}
获取到代理对象与逻辑增强
public Object getJdkProxy(Object obj) {
// 获取代理对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
// 写增强逻辑
System.out.println("中介（代理）收取服务费3000元");
// 调用原有业务逻辑
result = method.invoke(obj,args);
System.out.println("客户信息卖了3毛钱");
return result;
}
});
}
利用动态代理生成的代理对象完成租房业务并且增强了业务
public class JdkProxy {
public static void main(String[] args) {
IRentingHouse rentingHouse = new RentingHouseImpl(); // 委托对象---委托方
// 从代理对象工厂获取代理对象
IRentingHouse jdkProxy = (IRentingHouse) ProxyFactory.getInstance().getJdkProxy(rentingHouse);
jdkProxy.rentHosue();
}
}
2.2CGLIB动态代理
第三方功能,需要先引入cglib jar包;其获取动态代理对象方式如下代码,Enhancer类似于JDK动态代理中的Proxy,
生成增强代理对象的create方法有两个入参
1.Enhancer.create(obj.getClass():委托对象的class
2.new MethodInterceptor():增强的业务逻辑,这里是一个方法拦截器,通过实现接口MethodInterceptor能够对各个方法进行拦截增强，类似于JDK动态代理中的InvocationHandler
/**
* 使用cglib动态代理生成代理对象
* @param obj 委托对象
* @return
*/
public Object getCglibProxy(Object obj) {
return Enhancer.create(obj.getClass(), new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
Object result = null;
System.out.println("中介（代理）收取服务费3000元");
result = method.invoke(obj,objects);
System.out.println("客户信息卖了3毛钱");
return result;
}
});
}
