閉關修煉180天--手寫IOC和AOP(xml篇)
阿新 • • 發佈：2020-12-20
閉關修煉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帝莘，期待與你的技術交流和思想碰撞。
&n