关于spring的IOC和AOP

简述

谈这个首先要明白什么是IOC IOC（IoC Inversion of Control (控制反转/反转控制)），注意它是⼀个技术思想，不是⼀个技术实现
描述的事情： Java开发领域对象的创建，管理的问题

所要实现的事情就是我们可以不自己去new对象来使用 而是通过IOC容器去创建对象然后我们直接去IOC容器中取来使用

说到这里还有一个概念需要提及 DI：Dependancy Injection（依赖注⼊）

IOC和DI其实本质上说的是同一件事情，只不过角度不同，IOC是站在被注入对象的角度上 讲述这个对象被控制反转。而DI是站在容器的角度上 讲述这个容器将对象进行依赖注入。

然后就是AOP

AOP: Aspect oriented Programming ⾯向切⾯编程/⾯向⽅⾯编程
AOP是OOP的一个延续，或者说延伸

使代码在不改变原有逻辑的情况下 增强横切逻辑代码 根本上解藕 避免横切逻辑代码重复

下面来具体说明下关于Spring的IOC AOP的实现

首先 基于java的三层架构 我们想要在servlet中获取并使用或者service中获取并使用dao 那么我们最简单的方法便是new一个具体的实例来进行操作

但是这样的话 一直的new对象 又无法保证该对象会被按时回收 首先堆中会不断堆积 影响到jvm的具体性能 还有这样的代码耦合性太强 java的特点就是要考虑具体的解耦问题

那么 我们就需要考虑通过其他方式使该对象注入并能够使用

在这个情况下 我们就考虑到通过xml文件的方式去解决

　　首先通过xml文件将具体的class文件进行定义 确定其路径以及id 之后通过工厂的方式生产其对象

<bean>
    <bean id="AccountDao" class="com/lagou/edu/dao/AccountDao.java"/>
</bean>

// 实例化bean对象
for (int i = 0; i < list.size(); i++) {
   Element element = list.get(i);
   String id = element.attributeValue("id");
   String clazz = element.attributeValue("class");
   Class<?> aClass = Class.forName(clazz);
   Object o = aClass.newInstance();
   map.put(id, o);
}

通过工厂类将其实例化同时还要维护他的具体依赖关系 这个可以通过循环来处理他的property元素 之后  我们在将其放在map中以供之后方便使用

这样 我们就可以通过工厂类的方法来创建实力对象 解决代码的耦合问题

但是通过Spring框架我们可以知道这样并不是最简便的

毕竟还要在每一个里面通过BeanFactory.getBean("transferService")获取对象实例

但是直接写 private AccountDao accountDao 得到的实例对象其实是null

我们可以通过set方法来给他赋值 但这样我们首先要将bean对象的值进行下处理 使其set到对应的name中

// 维护bean之间的依赖关系
List<Element> propertyNodes =
        rootElement.selectNodes("//property");
for (int i = 0; i < propertyNodes.size(); i++) {
    Element element = propertyNodes.get(i);
    // 处理property元素
    String name = element.attributeValue("name");
    String ref = element.attributeValue("ref");
    String parentId =
            element.getParent().attributeValue("id");
    Object parentObject = map.get(parentId);
    Method[] methods = parentObject.getClass().getMethods();
    for (int j = 0; j < methods.length; j++) {
        Method method = methods[j];
        if (("set" + name).equalsIgnoreCase(method.getName())) {
            // bean之间的依赖关系（注⼊bean）
            Object propertyObject = map.get(ref);
            method.invoke(parentObject, propertyObject);
        }
    }
    // 维护依赖关系后重新将bean放⼊map中
    map.put(parentId, parentObject);

这样当我们通过

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao){
        this.accountDao = accountDao;
    }

的方式才能使accountDao的值不为null

处于实际问题 我们还要考虑关于事务的控制

如何保证事务的控制 那就要保证多次的commit操作使用的是同一个connection连接 方法 可以获取当前线程中的connection

    public Connection getCurrentThreadConn() throws SQLException {
        //判断当前线程中是否绑定连接 没有 从连接池获取一个绑定到当前线程
        Connection connection = threadLocal.get();
        if (threadLocal.get() == null) {
//            connection = DruidUtils.getInstance().getConnection();
            //从连接吃那连接并绑定到线程
            connection = dataSource.getConnection();
            //绑定当前线程
            threadLocal.set(connection);
        }
        return connection;
    }

这样的话 其实就算是基本还原了

不过 如果有大量的涉及到事务的操作时 我们就需要进行大量的重复操作

    try {
            TransactionManager.getInstance().beginTransaction();

            Account from = accountDao.queryAccountByCardNo(fromCardNo);
            Account to = accountDao.queryAccountByCardNo(toCardNo);
            from.setMoney(from.getMoney()-money);
            to.setMoney(to.getMoney()+money);
            accountDao.updateAccountByCardNo(from);
            accountDao.updateAccountByCardNo(to);

            TransactionManager.getInstance().commit();
        } catch (Exception e){
            e.printStackTrace();
            TransactionManager.getInstance().rollback();
            throw e;
        }

其中的开启事务 提交事务 包括捕获异常后的事务回滚我们都要大量的重复书写 这里就涉及到了动态代理模式的使用

代理模式

　　代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

其中还分为动态代理和静态代理

静态代理总结：

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

　　缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。

相对于静态代理来说 动态代理教完美的解决了这一问题 为什么说较完美呢 因为jdk的动态代理还是摆脱不了对于interface的依赖 对应的就是我们需要创建同数量的接口

这也是很大的工程

    @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);
    }

于是 更加方便的cjlib动态代理就应需产生了

    public static Object create(Class type, Callback callback) {
        Enhancer e = new Enhancer();
        e.setSuperclass(type);
        e.setCallback(callback);
        return e.create();
    }

可以跳过接口直接通过class来代理对象

所以 我们使用动态代理将大量的重复事务操作进行抽取 使代码不再臃肿

    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;
                try{
                    transactionManager.beginTransaction();

                    result = method.invoke(obj, objects);

                    transactionManager.commit();
                }catch (Exception e) {
                    e.printStackTrace();

                    transactionManager.rollback();

                    throw e;
                }

                return result;
            }
        });
    }

这样 我们就可以直接书写业务模块了