单例模式
Spring默认是单例的，如果Spring注解的bean中有成员变量，当多线程并发访问并修改此成员变量时，修改的是共享变量，会出现结果不正确的问题。
加载Spring bean
在Spring框架中，被注解的bean会放入Spring容器中，由Spring管理。
但是new出来的对象不会放入Spring容器，因此Spring也无法管理该对象。
这就导致了一个问题：new出来的对象中无法通过@Autowired注入Spring管理的 bean。
要想获得该Spring bean，可通过Spring上下文获取：
@Service("Tasks")
public class Tasks implements ApplicationContextAware {
private ApplicationContext applicationContext;
@Autowired
private TaskFactory factory;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
/**
* 获取Task实例
*
* @param beanName
* @return
*/
private ITask getTask(String beanName) {
ITask task = factory.findTask(this.applicationContext, beanName);
if (null != task) {
return task;
}
return null;
}
}
/**
* 任务工厂
*/
@Service("TaskFactory")
public class TaskFactory {
public ITask findTask(ApplicationContext ctx, String beanName) {
Object bean = ctx.getBean(beanName);
if (bean instanceof ITask) {
return (ITask) bean;
}
return null;
}
}
动态代理
Spring中AOP的基本原理就是动态代理。
参考：
https://www.cnblogs.com/gonjan-blog/p/6685611.html
https://www.cnblogs.com/jiyukai/p/6958744.html
https://www.cnblogs.com/xiaoluo501395377/p/3383130.html
https://blog.csdn.net/wangqyoho/article/details/77584832
代理模式
代理相当于在客户端和目标对象之间加了中间层，将客户端和目标对象隔开，客户端不直接调用目标对象，而是通过代理对象来调用目标对象。
公式： 公共接口 + 具体对象 = 代理对象
- 定义一个公共接口
- 具体对象完成业务逻辑
- 代理对象持有具体对象，增强功能的同时可调用具体对象完成业务逻辑
- 客户端使用代理对象
动态代理
在运行期间动态生成代理对象。
public class DynamicProxyProducer implements InvocationHandler {
// 加入被代理类
private Object originalObj;
private DynamicProxyProducer() {
}
public DynamicProxyProducer(Object originalObj) {
this.originalObj = originalObj;
}
/**
* 获取动态代理类实例
*
* @return
*/
public Object getProxy() {
Object proxy = Proxy.newProxyInstance(this.originalObj.getClass().getClassLoader(),
this.originalObj.getClass().getInterfaces(), this);
return proxy;
}
/**
* 动态代理类的切面，可以增强被代理类方法
* proxy: 代理对象
* method: 实例方法
* args: 实例方法参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("可以增强被代理类方法...");
System.out.println("被代理类: " + this.originalObj.getClass().getName());
System.out.println("动态代理类: " + proxy.getClass().getName());
// 正常返回被代理类方法
return method.invoke(this.originalObj, args);
}
}
关于Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)方法：
loader定义了由哪个ClassLoader来对生成的代理对象进行加载；
interfaces表示代理对象实现的公共接口；
h表示动态代理对象调用方法时关联的InvocationHandler对象，会被拦截到该InvocationHandler对象的invoke()方法内。
// 定义一个接口
public interface InterfaceA {
void a();
}
// 具体对象
public class A implements InterfaceA {
@Override
public void a() {
System.out.println("A-a()");
}
}
// 测试
public class DynamicProxyTest {
public static void main(String[] args) {
// 具体对象
A a = new A();
// 动态代理处理器
MyHandler handler = new MyHandler(a);
// 生成动态代理对象
InterfaceA proxyA = (InterfaceA) Proxy.newProxyInstance(a.getClass().getClassLoader(),
a.getClass().getInterfaces(), handler);
// 代理对象调用接口中方法，会被拦截到handler的invoke()内执行
proxyA.a();
}
}
// 输出：
代理对象: com.sun.proxy.$Proxy0
被代理对象: test.A
可在此处增强功能...
A-a()
总结：
（1）定义一个公共接口，具体类实现该接口；
（2）定义一个动态代理处理器InvocationHandler，并在处理器内加入具体对象
（3）利用Proxy.newProxyInstance()生成动态代理对象（类加载器、接口和处理器）
（4）利用动态代理对象调用具体对象方法时，会被拦截到处理器的invoke()方法处。
遇到问题及时记录更新
欢迎补充修正