Spring

---

单例模式

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

代理模式
代理相当于在客户端和目标对象之间加了中间层，将客户端和目标对象隔开，客户端不直接调用目标对象，而是通过代理对象来调用目标对象。

公式： 公共接口 + 具体对象 = 代理对象

1. 定义一个公共接口
2. 具体对象完成业务逻辑
3. 代理对象持有具体对象，增强功能的同时可调用具体对象完成业务逻辑
4. 客户端使用代理对象

动态代理
在运行期间动态生成代理对象。

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()方法处。

---

遇到问题及时记录更新
欢迎补充修正