一：spring基本认识
spring核心模块：
spring分为几大模块：
- web模块：操作servlet，提供了springmvc框架，提升了应用的解耦。
- 数据访问与集成（data access）：数据操作层，封装了api操作数据库， 提供了事务管理，连接管理等。还能集成一些优秀的持久层框架如mybatis等。
- 核⼼容器（Core Container）： spring的核心，维护bean的创建，管理等，包含了核心技术ioc的应用。 spring粗略看来，其实就是一套管理bean的框架。
- ⾯向切⾯编程（AOP）/Aspects Spring对⾯向切⾯编程提供了丰富的⽀持，
是Spring 中开发切⾯的基础，可以帮助解耦。- Test模块：单元测试。
核心思想：
spring核心思想，就是ioc和iop的应用：
ioc: 控制反转
控制就是指，对于对象的创建权利。 一般来说，是需要使用者自己去new对象的，spring中交给了框架来创建，我们要用的时候，只需要通过注解@Autowire注入。 也就是将创建权利交给了框架，所以叫控制反转。
另外也可以叫依赖注入，是因为框架在创建对象时，会将其依赖的对象也注入进去。 和ioc描述的一件事，只不过角度不同。
aop：⾯向切⾯编程
面向切面编程，是面向对象编程OOP的延续，OOP有三⼤特征：封装、继承和多态，是一种垂直架构。
在oop中，父类中有的功能，子类可以通过继承来获取，还可以在子类中扩展。 但是要给没有继承关系的类，实现一个公共行为，那就需要横向架构了，aop就是为了实现这一点。
二：手写ioc和aop
在正式学习spring的ioc和aop之前，先来手动写一个实现，感受一下。
先看一个没有ioc和aop的案例-银行转账：
表结构：
代码调用关系：
代码：
Servlet:
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author lf
*/
@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
// 1. 实例化service层对象
private TransferService transferService = new TransferServiceImpl();
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求体的字符编码
req.setCharacterEncoding("UTF-8");
String fromCardNo = req.getParameter("fromCardNo");
String toCardNo = req.getParameter("toCardNo");
String moneyStr = req.getParameter("money");
int money = Integer.parseInt(moneyStr);
Result result = new Result();
try {
// 2. 调用service层方法
transferService.transfer(fromCardNo,toCardNo,money);
result.setStatus("200");
} catch (Exception e) {
e.printStackTrace();
result.setStatus("201");
result.setMessage(e.toString());
}
// 响应
resp.setContentType("application/json;charset=utf-8");
resp.getWriter().print(JsonUtils.object2Json(result));
}
}
TransferService
接⼝及实现类
public interface TransferService {
void transfer(String fromCardNo,String toCardNo,int money) throws Exception;
}
public class TransferServiceImpl implements TransferService {
private AccountDao accountDao = new JdbcAccountDaoImpl();
@Override
public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {
Account from = accountDao.queryAccountByCardNo(fromCardNo);
Account to = accountDao.queryAccountByCardNo(toCardNo);
from.setMoney(from.getMoney()-money);
to.setMoney(to.getMoney()+money);
accountDao.updateAccountByCardNo(to);
accountDao.updateAccountByCardNo(from);
}
}
dao层：
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public interface AccountDao {
Account queryAccountByCardNo(String cardNo) throws Exception;
int updateAccountByCardNo(Account account) throws Exception;
}
public class JdbcAccountDaoImpl implements AccountDao {
@Override
public Account queryAccountByCardNo(String cardNo) throws Exception {
//从连接池获取连接
Connection con = DruidUtils.getInstance().getConnection();
String sql = "select * from account where cardNo=?";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setString(1,cardNo);
ResultSet resultSet = preparedStatement.executeQuery();
Account account = new Account();
while(resultSet.next()) {
account.setCardNo(resultSet.getString("cardNo"));
account.setName(resultSet.getString("name"));
account.setMoney(resultSet.getInt("money"));
}
resultSet.close();
preparedStatement.close();
con.close();
return account;
}
@Override
public int updateAccountByCardNo(Account account) throws Exception {
// 从连接池获取连接
Connection con = DruidUtils.getInstance().getConnection();
String sql = "update account set money=? where cardNo=?";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setInt(1,account.getMoney());
preparedStatement.setString(2,account.getCardNo());
int i = preparedStatement.executeUpdate();
preparedStatement.close();
con.close();
return i;
}
}
public class DruidUtils {
private DruidUtils(){
}
private static DruidDataSource druidDataSource = new DruidDataSource();
static {
druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
druidDataSource.setUrl("jdbc:mysql://localhost:3306/bank");
druidDataSource.setUsername("root");
druidDataSource.setPassword("123456");
}
public static DruidDataSource getInstance() {
return druidDataSource;
}
}上述代码问题分析：
1、new service 和 new dao，将具体实现类耦合在一起，如果要切换实现类需要改代码，不符合面向接口开发。
2、service层没有事务控制，存在隐患。
解决方案：
问题1：不使用new，将类的全限定名配置到xml，通过反射来实例化。 当然不可能每个地方来使用反射逻辑呢，因为有很多类都需要实例化，可以选择工厂模式来创建对象，达到解耦。
问题2：在service添加事务，手动控制jdbc的Connection事务。 为了保证多次操作在一个事务里执行，就不能像上述代码中，每调用一次update就使用一个新的Connection。 这时候就需要将一个Connection与当前线程绑定在一起。
具体代码实现：
问题一：
bean.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置-->
<beans>
<!--id标识对象，class是类的全限定类名-->
<bean id="accountDao" class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl">
<!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值-->
<property name="AccountDao" ref="accountDao"></property>
</bean>
<bean id="transferService" class="com.lagou.edu.service.impl.TransferServiceImpl">
<!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值-->
<property name="AccountDao" ref="accountDao"></property>
</bean>
</beans>有了xml后，需要一个工厂通过反射，来实例化bean。
BeanFactory扫描xml，完成bean的创建和自动注入
/**
* @author 应癫
*
* 工厂类，生产对象（使用反射技术）
*/
public class BeanFactory {
/**
* 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
* 任务二：对外提供获取实例对象的接口（根据id获取）
*/
private static Map<String,Object> map = new HashMap<>(); // 存储对象
static {
// 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
// 加载xml
InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
// 解析xml
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(resourceAsStream);
Element rootElement = document.getRootElement();
List<Element> beanList = rootElement.selectNodes("//bean");
for (int i = 0; i < beanList.size(); i++) {
Element element = beanList.get(i);
// 处理每个bean元素，获取到该元素的id 和 class 属性
String id = element.attributeValue("id"); // accountDao
String clazz = element.attributeValue("class"); // com.lagou.edu.dao.impl.JdbcAccountDaoImpl
// 通过反射技术实例化对象
Class<?> aClass = Class.forName(clazz);
Object o = aClass.newInstance(); // 实例化之后的对象
// 存储到map中待用
map.put(id,o);
}
// 实例化完成之后，需要维护对象的依赖关系，查看有property子元素的bean，通过set方法注入。
List<Element> propertyList = rootElement.selectNodes("//property");
// 解析property，获取父元素
for (int i = 0; i < propertyList.size(); i++) {
Element element = propertyList.get(i); //<property name="AccountDao" ref="accountDao"></property>
String name = element.attributeValue("name");
String ref = element.attributeValue("ref");
// 找到当前需要被处理依赖关系的bean
Element parent = element.getParent();
// 调用父元素对象的反射功能
String parentId = parent.attributeValue("id");
Object parentObject = map.get(parentId);
// 遍历父对象中的所有方法，找到"set" + name
Method[] methods = parentObject.getClass().getMethods();
for (int j = 0; j < methods.length; j++) {
Method method = methods[j];
if(method.getName().equalsIgnoreCase("set" + name)) { // 该方法就是 setAccountDao(AccountDao accountDao)
method.invoke(parentObject,map.get(ref));
}
}
// 把处理之后的parentObject重新放到map中
map.put(parentId,parentObject);
}
} 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();
}
}
// 任务二：对外提供获取实例对象的接口（根据id获取）
public static Object getBean(String id) {
return map.get(id);
}
}经过BeanFactory，所有的bean都放到了map中，并且也设置了属性依赖。
在servlet，就可以通过BeanFactory获取属性依赖transferService
private TransferService transferService = (TransferService)BeanFactory.getBean("transferService");问题二：
使用ConnectionUtils将Connection与当前线程绑定:
public class ConnectionUtils {
private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); // 存储当前线程的连接
/**
* 从当前线程获取连接
*/
public Connection getCurrentThreadConn() throws SQLException {
/**
* 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取一个连接绑定到当前线程
*/
Connection connection = threadLocal.get();
if(connection == null) {
// 从连接池拿连接并绑定到线程
connection = DruidUtils.getInstance().getConnection();
// 绑定到当前线程
threadLocal.set(connection);
}
return connection;
}
}
public class DruidUtils {
private DruidUtils(){
}
private static DruidDataSource druidDataSource = new DruidDataSource();
static {
druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
druidDataSource.setUrl("jdbc:mysql://localhost:3306/bank");
druidDataSource.setUsername("root");
druidDataSource.setPassword("123456");
}
public static DruidDataSource getInstance() {
return druidDataSource;
}
}
事务管理器TransactionManager ：
public class TransactionManager {
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
// 开启手动事务控制
public void beginTransaction() throws SQLException {
connectionUtils.getCurrentThreadConn().setAutoCommit(false);
}
// 提交事务
public void commit() throws SQLException {
connectionUtils.getCurrentThreadConn().commit();
}
// 回滚事务
public void rollback() throws SQLException {
connectionUtils.getCurrentThreadConn().rollback();
}
}有了事务管理器，我们要在service层来使用，达到控制事务的目的。 我们可以在service的代码中，手动创建事务管理器，调用开启，提交或回滚事务的方法。 但是，这样就和业务代码搅合在一起。 这时候，可以创建一个service代理，在代理中完成事务的控制。
创建代理的工具ProxyFactory：
/**
* @author 应癫
*
*
* 代理对象工厂：生成代理对象的
*/
public class ProxyFactory {
private TransactionManager transactionManager;
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
/**
* Jdk动态代理
* @param obj 委托对象
* @return 代理对象
*/
public Object getJdkProxy(Object obj) {
// 获取代理对象
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try{
// 开启事务(关闭事务的自动提交)
transactionManager.beginTransaction();
result = method.invoke(obj,args);
// 提交事务
transactionManager.commit();
}catch (Exception e) {
e.printStackTrace();
// 回滚事务
transactionManager.rollback();
// 抛出异常便于上层servlet捕获
throw e;
}
return result;
}
});
}
/**
* 使用cglib动态代理生成代理对象
* @param obj 委托对象
* @return
*/
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();
// 抛出异常便于上层servlet捕获
throw e;
}
return result;
}
});
}
}将上面三个类，配置到bean.xml中：
<!--配置新增的三个Bean-->
<bean id="connectionUtils" class="com.lagou.edu.utils.ConnectionUtils"></bean>
<!--事务管理器-->
<bean id="transactionManager" class="com.lagou.edu.utils.TransactionManager">
<property name="ConnectionUtils" ref="connectionUtils"/>
</bean>
<!--代理对象工厂-->
<bean id="proxyFactory" class="com.lagou.edu.factory.ProxyFactory">
<property name="TransactionManager" ref="transactionManager"/>
</bean>修改 JdbcAccountDaoImpl，从连接池获取连接：
public class JdbcAccountDaoImpl implements AccountDao {
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
public void init() {
System.out.println("初始化方法.....");
}
public void destory() {
System.out.println("销毁方法......");
}
@Override
public Account queryAccountByCardNo(String cardNo) throws Exception {
//从连接池获取连接
Connection con = connectionUtils.getCurrentThreadConn();
String sql = "select * from account where cardNo=?";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setString(1,cardNo);
ResultSet resultSet = preparedStatement.executeQuery();
Account account = new Account();
while(resultSet.next()) {
account.setCardNo(resultSet.getString("cardNo"));
account.setName(resultSet.getString("name"));
account.setMoney(resultSet.getInt("money"));
}
resultSet.close();
preparedStatement.close();
//con.close();
return account;
}
@Override
public int updateAccountByCardNo(Account account) throws Exception {
// 从连接池获取连接
// 改造为：从当前线程当中获取绑定的connection连接
//Connection con = DruidUtils.getInstance().getConnection();
Connection con = connectionUtils.getCurrentThreadConn();
String sql = "update account set money=? where cardNo=?";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setInt(1,account.getMoney());
preparedStatement.setString(2,account.getCardNo());
int i = preparedStatement.executeUpdate();
preparedStatement.close();
//con.close();
return i;
}
}
在servlet中使用service的代理：
private TransferService transferService = (TransferService) proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;到这里，代码就算完成了。 对于问题一和问题二的解决方式，就是ioc和aop的实现。
问题一通过bean.xml配置，在BeanFactory中读取创建bean，并通过set方法自动完成property
属性依赖的注入。
问题二通过代理，在业务方法前后完成了事务的管理，这是一种横向的处理方式，并不是纵向继承。