闭关修炼180天--手写IOC和AOP(xml篇)

帝莘

首先先分享一波思维导图，涵盖了一些Spring的知识点，当然这里并不全面，后期我会持续更新知识点。

在手写实现IOC和AOP之前（也就是打造一个简单的Spring框架），先简单的了解一些Spring以及它的两个核心思想IOC和AOP的相关概念。

Spring：

　　概述：spring是分层的全栈轻量级开源框架，以ioc和AOP为内核，提供了展现层spring mvc和业务层管理等众多的企业应用技术，还能整合众多开源的第三方框架。

　　优势：1.方便解耦，简化开发 2.AOP编程的支持 3.声明式事务的支持。4.方便程序的测试。5.方便集成各种优秀框架 6.降低javaEE API的使用难度。6.源码是经典的java学习案例。

　　Spring 的核⼼结构：Spring是⼀个分层⾮常清晰并且依赖关系、职责定位⾮常明确的轻量级框架，主要包括⼏个⼤模块：数据处理模块、Web模块、AOP（Aspect Oriented Programming）/Aspects模块、

Core Container模块和 Test 模块，如下图所示，Spring依靠这些基本模块，实现了⼀个令⼈愉悦的融合了现有解决⽅案的零侵⼊的轻量级框架。

IOC:　

　　IOC概念：控制反转，它是一个技术思想，不是一个技术实现，描述的事情是：java开发领域对象的创建，管理的问题。

　　传统开发方式：比如A依赖于B，往往会在A中new一个B的对象。

　　IOC思想下的开发方式：我们不用自己去new对象了，而是由IOC容器（Spring框架）去帮助我们实例化对象并且管理它，我们需要使用哪个对象，去问IOC容器要即可。我们丧失了一个权力（创建、管理对

象的权力），得到了一个福利（不用考虑对象的创建、管理一系列事情）

　　为什么叫控制反转？控制：指的是对象创建（实例化、管理）的权力；反转：控制权交给了外部环境（spring框架）

　　IOC解决了什么问题：IOC解决了对象之间的耦合问题

　　IOC和DI的区别？IOC是控制反转，DI是依赖注入。

　　怎么理解：IOC和DI描述的是一件事情（对象实例化及依赖关系维护这件事），不过角度不同。

　　IOC是站在对象的角度，对象实例化及其管理的权力交给了（反转）容器。

　　DI是站在容器的角度，容器会把对象依赖的其他对象注入（送过去），比如A对象实例化过程中因为声明了一个B类型的属性，那么就需要容器把B对象注入给A。

手写Spring框架流程：

实现思路：

编写xml文件，在根标签beans下条件bean，每一组bean对应一个需要加入容器管理的对象。
编写BeanFactory：解析xml文件，将解析出的一个个bean装载进map集合中，其中id为bean标签内id属性的值，value为根据bean标签内class属性的全路径值反射得到的目标类的实例对象。
BeanFactory还要提供一个获取实例的方法getBean(String id)
为了添加不同类的依赖关系，在xml文件里面的bean标签组内添加property标签，其中property内的name属性的值是父标签所代表的类的set方法后面的名字，ref属性的值是它所依赖的对象的bean-id。在BeanFactory中进一步解析，把对应依赖关系添加进对象中，更新map。
配置事务，保证一个线程使用一个数据库连接，根据代理模式生产代理对象，根据代理对象回调用invoke方法的特性，在原方法前后增加事务增强，在这里，具体的事务管理我们交给TransactionManager类进行具体的管理，配置好代理类和事务管理类之间的依赖关系。

代码实现：

　　先看一下整体的项目结构：

　　sql建表语句：

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------

-- Table structure for users

-- ----------------------------

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (

  `id` int(11) NOT NULL,

  `username` varchar(255) COLLATE utf8_bin DEFAULT NULL,

  `balance` double(11,0) DEFAULT NULL,

  PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

-- ----------------------------

-- Records of users

-- ----------------------------

INSERT INTO `users` VALUES ('1', '汪苏泷', '1000');

INSERT INTO `users` VALUES ('2', '薛之谦', '1000');

　　几个pom依赖

<!--dom4j-->

        <dependency>

            <groupId>dom4j</groupId>

            <artifactId>dom4j</artifactId>

            <version>1.6.1</version>

        </dependency>

        <dependency>

            <groupId>jaxen</groupId>

            <artifactId>jaxen</artifactId>

            <version>1.1.6</version>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>5.1.17</version>

        </dependency>

        <dependency>

            <groupId>c3p0</groupId>

            <artifactId>c3p0</artifactId>

            <version>0.9.1.2</version>

        </dependency>

        <!--引入cglib依赖-->

        <dependency>

            <groupId>cglib</groupId>

            <artifactId>cglib</artifactId>

            <version>2.1_2</version>

        </dependency>

　　xml文件代码：bean.xml

<?xml version="1.0" encoding="UTF-8" ?>

<beans>

    <bean id="UserDao" class="com.radorm.spring.dao.impl.UserDaoImpl">

        <property name="ConnectionUtils" ref="ConnectionUtils"></property>

    </bean>

    <bean id="UserService" class="com.radorm.spring.service.impl.UserServiceImpl">

        <property name="UserDao" ref="UserDao"></property>

    </bean>

    <bean id="ConnectionUtils" class="com.radorm.spring.utils.ConnectionUtils"></bean>

    <bean id="TransactionManager" class="com.radorm.spring.utils.TransactionManager">

        <property name="ConnectionUtils" ref="ConnectionUtils"></property>

    </bean>

    <bean id="ProxyFactory" class="com.radorm.spring.factory.ProxyFactory">

        <property name="TransactionManager" ref="TransactionManager"></property>

    </bean>

</beans>

　　三个工具类：DataSourceUtils ConnectionUtils ，TransactionManager

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;

import java.beans.PropertyVetoException;

import java.sql.Connection;

import java.sql.SQLException;

public class DataSourceUtils {

    private DataSourceUtils(){}

    private static DataSourceUtils dataSourceUtils = new DataSourceUtils();

    public static DataSourceUtils getInstance(){

        return dataSourceUtils;

    }

    public DataSource createDataSource(){

        //创建连接池

        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        try {

            dataSource.setDriverClass("com.mysql.jdbc.Driver");

            dataSource.setJdbcUrl("jdbc:mysql:///mybatis");

            dataSource.setUser("root");

            dataSource.setPassword("root");

        } catch (PropertyVetoException e) {

            e.printStackTrace();

        }

        return dataSource;

    }

    public Connection getConnection(){

        DataSource dataSource = createDataSource();

        try {

            return dataSource.getConnection();

        } catch (SQLException e) {

            e.printStackTrace();

        }

        return null;

    }

}

import java.sql.Connection;

public class ConnectionUtils {

    /**

     * 声明当前线程

     */

    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    /**

     * 获取当前线程里面的连接

     * @return

     */

    public Connection getLocalConnection(){

        Connection connection = threadLocal.get();

        if(connection == null){

            //如果在当前线程内获取不到连接，那就在线程池中获取，并且放到当前线程中

            connection = DataSourceUtils.getInstance().getConnection();

            threadLocal.set(connection);

        }

        return connection;

    }

}

import java.sql.SQLException;

/**

 * 事务管理工厂

 */

public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {

        this.connectionUtils = connectionUtils;

    }

    public void beginTransaction() throws SQLException {

        connectionUtils.getLocalConnection().setAutoCommit(false);

    }

    public void commitTransaction() throws SQLException{

        connectionUtils.getLocalConnection().commit();

    }

    public void rollbackTransaction(){

        try {

            connectionUtils.getLocalConnection().rollback();

        } catch (SQLException e) {

            e.printStackTrace();

        }

    }

}

　　两个工厂类：BeanFactory，ProxyFactory

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class BeanFactory {

    private static Map<String,Object> map = new HashMap<>();

    /**

     * 1.使用dom4j技术读取配置文件信息

     * 2.将读取到的对象以及key封装进map中

     * key = id，value = class反射产生的实例对象

     */

    static {

        //根据xml的路径加载为字节流到内存中

        InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");

        SAXReader saxReader = new SAXReader();

        try {

            //读取该字节流为document

            Document document = saxReader.read(inputStream);

            //获取根标签下的元素

            Element rootElement = document.getRootElement();

            //获取根标签内部所有的bean标签里面的内容

            List<Element> beanList = rootElement.selectNodes("//bean");

            for (Element element : beanList) {

                //根据属性名获取bean标签里面的内容

                String id = element.attributeValue("id");

                String aClass = element.attributeValue("class");

                //利用反射技术根据全路径获取类对象

                Class<?> aClass1 = Class.forName(aClass);

                //根据类对象获取实例

                Object o = aClass1.newInstance();

                //组装map

                map.put(id,o);

            }

            //获取所有的property

            List<Element> propertyList = rootElement.selectNodes("//property");

            for (Element element : propertyList) {

                //获取property标签里面的属性值

                String name = element.attributeValue("name");

                String ref = element.attributeValue("ref");

                //获取父标签

                Element parentElement = element.getParent();

                //获取父标签的id

                String parentId = parentElement.attributeValue("id");

                //根据父标签的id获取出父标签的实例化对象

                Object parentObj = map.get(parentId);

                //获取父对象想要添加依赖的实例化对象

                Object refObj = map.get(ref);

                //获取父对象的所有方法

                Method[] methods = parentObj.getClass().getMethods();

                for (Method method : methods) {

                    String methodName = method.getName();

                    //判断是否是set方法

                    if(methodName.equalsIgnoreCase("set"+name)){

                        //往方法中传入参数

                        method.invoke(parentObj,refObj);

                    }

                }

                //重新将父对象加入到map中

                map.put(parentId,parentObj);

            }

        } catch (DocumentException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (InstantiationException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        }

    }

    public static <T> T getBean(String id){

        return (T) map.get(id);

    }

}

import com.radorm.spring.utils.TransactionManager;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

 * JDK动态代理工厂

 */

public class ProxyFactory {

    private TransactionManager transactionManager;

    public void setTransactionManager(TransactionManager transactionManager) {

        this.transactionManager = transactionManager;

    }

    /**

     * jdk动态代理：要求被代理的对象实现了接口

     * @param object 委托对象

     * @param <T> 代理对象

     * @return

     */

    public <T> T getProxyJDK(Object object){

       Object result =  Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Object re = null;

                try {

                    //开启事务

                    transactionManager.beginTransaction();

                    re = method.invoke(object,args);

                    //提交事务

                    transactionManager.commitTransaction();

                } catch (Exception e) {

                    e.printStackTrace();

                    //回滚事务

                    transactionManager.rollbackTransaction();

                    throw e;

                }

                return re;

            }

        });

       return (T) result;

    }

    /**

     *  cglib动态代理

     * @param obj 委托对象

     * @param <T> 代理对象

     * @return

     */

    public <T> T getProxyCglib(Object obj){

        Object result = Enhancer.create(obj.getClass(), new MethodInterceptor() {

            @Override

            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                Object od = null;

                try {

                    //开启事务

                    transactionManager.beginTransaction();

                    od = method.invoke(obj,objects);

                    //提交事务

                    transactionManager.commitTransaction();

                } catch (Exception e) {

                    e.printStackTrace();

                    //回滚事务

                    transactionManager.rollbackTransaction();

                    throw e;

                }

                return od;

            }

        });

        return (T) result;

    }

}

　　一个pojo：Users

public class Users {

    private Integer id;

    private String username;

    private Double balance;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public Double getBalance() {

        return balance;

    }

    public void setBalance(Double balance) {

        this.balance = balance;

    }

    public Users(Integer id, String username, Double balance) {

        this.id = id;

        this.username = username;

        this.balance = balance;

    }

}

　　一个dao + 它的impl：UserDao + UserDaoImpl

import com.radorm.spring.pojo.Users;

public interface UserDao {

    void draw();

    Users select(Integer id);

    void updateUsers(Users users);

}

import com.radorm.spring.dao.UserDao;

import com.radorm.spring.pojo.Users;

import com.radorm.spring.utils.ConnectionUtils;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

public class UserDaoImpl implements UserDao {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {

        this.connectionUtils = connectionUtils;

    }

    @Override

    public void draw() {

        System.out.println("11111111");

    }

    @Override

    public Users select(Integer id) {

        Connection connection = connectionUtils.getLocalConnection();

        try {

            PreparedStatement preparedStatement = connection.prepareStatement("select * from users where id = ?");

            preparedStatement.setObject(1,id);

            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()){

                int id1 = resultSet.getInt("id");

                String username = resultSet.getString("username");

                double balance = resultSet.getDouble("balance");

                Users  users = new Users(id1,username,balance);

                return users;

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

        return null;

    }

    @Override

    public void updateUsers(Users users) {

        Connection localConnection = connectionUtils.getLocalConnection();

        try {

            PreparedStatement preparedStatement = localConnection.prepareStatement("update users set username = ?,balance = ? where id = ?");

            preparedStatement.setString(1,users.getUsername());

            preparedStatement.setDouble(2,users.getBalance());

            preparedStatement.setInt(3,users.getId());

            preparedStatement.executeUpdate();

        } catch (SQLException e) {

            e.printStackTrace();

        }

    }

}

　　一个service+它的impl：UserService，UserServiceImpl

public interface UserService {

    void transfer(Integer fromId,Integer toId,Double money) throws Exception;

}

import com.radorm.spring.dao.UserDao;

import com.radorm.spring.pojo.Users;

import com.radorm.spring.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {

        this.userDao = userDao;

    }

    @Override

    public void transfer(Integer fromId, Integer toId, Double money) throws Exception {

            Users from = userDao.select(fromId);

            Users to = userDao.select(toId);

            from.setBalance(from.getBalance() - money);

            to.setBalance(to.getBalance() + money);

            userDao.updateUsers(from);

           //该异常代码可以选择打开或者关闭，检验事务的作用

           //int i = 1/0

            userDao.updateUsers(to);

    }

}

　　test:BeanTest

import com.radorm.spring.factory.ProxyFactory;

import com.radorm.spring.service.UserService;

import com.radorm.spring.factory.BeanFactory;

import org.junit.Test;

public class BeanTest {

    @Test

    public void test_bean(){

        ProxyFactory proxyFactory =  BeanFactory.getBean("ProxyFactory");

        UserService userService  = proxyFactory.getProxyJDK(BeanFactory.getBean("UserService"));

        try {

            userService.transfer(1,2,100d);

            System.out.println("转账成功");

        } catch (Exception e) {

            System.out.println("转账失败");

        }

    }

}

到此代码完成！

我是Slience帝莘，期待与你的技术交流和思想碰撞。