1wang

Spring框架

第一部分 Spring概述

1、Spring简介

Spring 是分层的 full-stack(全栈) 轻量级开源框架，以 IoC 和 AOP 为内核，提供了展现层 Spring MVC 和业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，已经成为使用最多的 Java EE 企业应用开源框架。
Spring 官方网址:https://spring.io
我们经常说的 Spring 其实指的是Spring Framework(spring 框架)。

2、Spring 的优势

整个 Spring 优势，传达出一个信号，Spring 是一个综合性，且有很强的思想性框架，每学习一天，就能体会到它的一些优势。

方便解耦，简化开发
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP编程的支持
通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
声明式事务的支持
@Transactional
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架(Struts、Hibernate、Hessian、 Quartz等)的直接支持。
降低JavaEE API的使用难度
Spring对JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层，使这些API的使用难度大为降低。
源码是经典的 Java 学习范例
Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

3、Spring 核心结构

Spring是一个分层非常清晰并且依赖关系、职责定位非常明确的轻量级框架。

主要包括几个大模块:

Date Access 数据处理模块
Spring的JDBC和DAO模块封装了大量样板代码，这样可以使得数据库代码变得简洁，也可以更专注于我们的业务，还可以避免数据库资源释放失败而引起的问题。另外，Spring AOP为数据访问提供了事务管理服务，同时Spring还对ORM进行了集成，如Hibernate、MyBatis等。该模块由 JDBC、Transactions、ORM、OXM 和 JMS 等模块组成。
Web模块
该模块提供了SpringMVC框架给Web应用，还提供了多种构建和其它应用交互的远程调用方案。 SpringMVC框架在Web层提升了应用的松耦合水平。
AOP(Aspect Oriented Programming)/Aspects模块
面向切面编程(AOP)/Aspects Spring对面向切面编程提供了丰富的支持。这个模块是Spring应用系统中开发切面的基础，与DI一样，AOP可以帮助应用对象解耦。
Core Container模块
Spring核心容器(Core Container) 容器是Spring框架最核心的部分，它管理着Spring应用中 bean的创建、配置和管理。在该模块中，包括了Spring bean工厂，它为Spring提供了DI的功能。基于bean工厂，我们还会发现有多种Spring应用上下文的实现。所有的Spring模块都构建于核心容器之上。
Test 模块
为了使得开发者能够很方便的进行测试，Spring提供了测试模块以致力于Spring应用的测试。通过该模块，Spring为使用Servlet、JNDI等编写单元测试提供了一系列的mock对象实现。

Spring依靠这些基本模块，实现了一个令人愉悦的融合了现有解决方案的零侵入的轻量级框架。

##################################################################################################

第二部分核心思想

1、IoC

Inversion of Control (控制反转/反转控制)
它是一种技术思想而不是一个技术实现，处理的核心是Java开发领域对象的创建，管理。

对于传统的开发方式：比如类A依赖于类B，往往会在类A中new一个B的对象，而在IoC思想下开发方式：不用自己去new对象了，而是由IoC容器(Spring框架)去帮助我们实例化对象并且管理它，我们需要使用哪个对象，去问IoC容器要即可。

控制: 指的是对象实例化、管理的权利。

反转: 控制权交给了IoC容器（spring框架）。

IoC解决对象之间的耦合问题

DI: Dependency Injection(依赖注入) ，IOC和DI描述的是同一件事情，只不过思考⻆度不一样

2、AOP

AOP: Aspect oriented Programming 面向切面编程/面向方面编程（AOP是OOP的延续）

OOP三大特征:封装、继承和多态（一种垂直继承体系）

OOP编程思想可以解决大多数的代码重复问题，但是有一些情况是处理不了的，比如下面的在顶级父类 Animal中的多个方法中相同位置出现了重复代码：例如日志/权限/事务等等，OOP就解决不了

横切逻辑代码

存在的问题:

横切代码重复问题
横切逻辑代码和业务代码混杂在一起，代码臃肿，维护不方便

AOP提出横向抽取机制，将横切逻辑代码和业务逻辑代码进行拆分，解耦合，避免横切逻辑代码重复。

「切」: 指的是横切逻辑，原有业务逻辑代码我们不能动，只能操作横切逻辑代码，所以面向横切逻辑。
「面」: 横切逻辑代码往往要影响的是很多个方法，每一个方法都如同一个点，多个点构成面，有一个面的概念在里面

##################################################################################################

第三部分手写实现 IoC 和 AOP

此处准备了一个『银行转账』的案例，请分析该案例在代码层次有什么问题 ?分析之后使用我们已有知识解决这些问题(痛点)。其实这个过程我们就是在一步步分析并手写实现 IoC 和 AOP。

银行转账案例及代码调用关系

银行转账案例关键代码

TransferServlet

@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(from);
		accountDao.updateAccountByCardNo(to); 
	}
}

AccountDao层接口及基于Jdbc的实现类

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

代码问题分析

问题一:
在上述案例实现中，直接在service实现类TransferServiceImpl中通过 AccountDao accountDao = new JdbcAccountDaoImpl() new对象方式获取dao层对象使用，而直接new对象方式却将TransferServiceImpl和dao层具体的一个实现类JdbcAccountDaoImpl 耦合在了一起，如果说技术架构发生一些变动，dao层的实现要使用其它技术，比如Mybatis, 那么每一个new Dao对象的service实现类的地方都需要修改源代码，重新编译，成本巨大。
问题二:
service层代码没有进行事务控制，如果在转账过程中出现异常，将可能导致数据库数据错乱，后果可能会很严重，尤其是在金融业务中。

解决思路

针对问题一：实例化对象的方式除了 new 之外，还可以通过反射技术，考虑使用工厂模式来解耦合，而且项目中往往有很多对象需要实例化，那就在工厂中使用反射技术实例化对象，很合适。（需要把类的全限定类名配置在xml中）

更进一步，代码中只声明所需实例的接口类型，不出现 new 也不出现工厂类的字眼，此时就需要声明一个变量并提供 set 方法，在反射的时候将所需要的对象注入进去
针对问题二：service 层添加上事务控制，手动控制JDBC Connection 事务，但要特别注意将Connection和当前线程绑定(即保证一个线程只有一个 Connection，这样操作才针对的是同一个 Connection，进而控制的是同一个事务)

代码升级

针对问题一的代码升级

beans.xml

 

<beans>
	<bean id="transferService" class="com.demo.edu.service.impl.TransferServiceImpl">
		<property name="AccountDao" ref="accountDao">property> 
	bean>
	<bean id="accountDao" class="com.demo.edu.dao.impl.JdbcAccountDaoImpl"/>
beans>

增加Bean解析创建工厂 BeanFactory.java

public class BeanFactory {
	/**
	* 工厂类的两个任务
	* 任务一:加载解析xml，读取xml中的bean信息，通过反射技术实例化bean对象，然后放入map待用
	* 任务二:提供接口方法根据id从map中获取bean(静态方法) 
	* */
	private static Map<String,Object> map = new HashMap<>();
	
	static {
		InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml"); 
		SAXReader saxReader = new SAXReader();
		try {
			Document document = saxReader.read(resourceAsStream); 
			Element rootElement = document.getRootElement(); 
			List<Element> list = rootElement.selectNodes("//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);
			}
			
			// 维护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);
		 	}
	    } 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 Object getBean(String id) { return map.get(id);
	} 
}

修改 TransferServlet

@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
    // 实例化service层对象
    //private TransferService transferService = new TransferServiceImpl();
    
    // 首先从BeanFactory获取到proxyFactory代理工厂的实例化对象
    private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");

    // ...
}

修改 TransferServiceImpl

public class TransferServiceImpl implements TransferService {
	//private AccountDao accountDao = new JdbcAccountDaoImpl();
    
    //注入 声明Dao接口对象
    private AccountDao accountDao;
    // 构造函数传值/set方法传值
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

针对问题二的改造

增加 ConnectionUtils

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

增加 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();
    }
}

增加 ProxyFactory 代理工厂类

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

修改 beans.xml



<beans>
    
    <bean id="accountDao" class="com.demo.edu.dao.impl.JdbcAccountDaoImpl">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    bean>
    
    <bean id="transferService" class="com.demo.edu.service.impl.TransferServiceImpl">
        
        <property name="AccountDao" ref="accountDao">property>
    bean>

    
    <bean id="connectionUtils" class="com.demo.edu.utils.ConnectionUtils"/>

    
    <bean id="transactionManager" class="com.demo.edu.utils.TransactionManager">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    bean>

    
    <bean id="proxyFactory" class="com.demo.edu.factory.ProxyFactory">
        <property name="TransactionManager" ref="transactionManager"/>
    bean>
beans>

修改 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 = DruidUtils.getInstance().getConnection();
        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;
    }
}

修改 TransferServlet

@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {

    // 1. 实例化service层对象
    //private TransferService transferService = new TransferServiceImpl();
    
    // 从工厂获取委托对象（委托对象是增强了事务控制的功能）
    // 首先从BeanFactory获取到proxyFactory代理工厂的实例化对象
    private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
    private TransferService transferService = (TransferService)proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;

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

##################################################################################################

第四部分 Spring IOC 应用

Spring IoC基础

启动 IoC 容器的方式

Java环境下启动IoC容器
1、ClassPathXmlApplicationContext:从类的根路径下加载配置文件(推荐使用)
2、FileSystemXmlApplicationContext:从磁盘路径上加载配置文件
3、AnnotationConfigApplicationContext:纯注解模式下启动Spring容器
Web环境下启动IoC容器

DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
 <display-name>Archetype Created Web Applicationdisplay-name>


 
 

 
 <context-param>
   <param-name>contextClassparam-name>
   <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContextparam-value>
 context-param>

 
 <context-param>
   <param-name>contextConfigLocationparam-name>
   <param-value>com.lagou.edu.SpringConfigparam-value>
 context-param>

 
 <listener>
   <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
 listener>
web-app>

BeanFactory是Spring框架中IoC容器的顶层接口,它只是用来定义一些基础功能,定义一些基础规范；ApplicationContext是它的一个子接口。
通常，我们称BeanFactory为SpringIOC的基础容器，ApplicationContext是容器的高级接口，比BeanFactory要拥有更多的功能，比如说国际化支持和资源访问(xml，java配置类)等等

纯XML模式开发

xml文件头


<beans xmlns="http://www.springframework.org/schema/beans" 
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd">

实例化Bean，有三种方式
1、无参构造函数：在默认情况下，它会通过反射调用无参构造函数来创建对象；如果类中没有无参构造函数，将创建失败。
配置XML


<bean id="userService" class="com.lagou.service.impl.TransferServiceImpl"> bean>

另外两种方式是为了我们自己new的对象加入到SpringIOC容器管理

2、静态方法：在实际开发中，我们使用的对象有些时候并不是直接通过构造函数就可以创建出来的，它可能在创建的过程中会做很多额外的操作。此时会提供一个创建对象的方法，不用先new对象，static方法可以直接调用，在该方法里实例化对象。
例如JDBC操作链接MySql数据库，我们不会直接去写 JDBC4Connection connection = new JDBC4Connection()，因为我们要注册驱动，还要提供URL和凭证信息，用 DriverManager.getConnection 方法来获取连接。

public class CreateBeanFactory {
    public static ConnectionUtils getInstanceStatic() {
        return new ConnectionUtils();
    }
}


<bean id="connectionUtils" class="com.lagou.factory.CreateBeanFactory" factory-method="getInstanceStatic">bean>

3、实例化方法创建

public class CreateBeanFactory {
    public ConnectionUtils getInstance() {
        return new ConnectionUtils();
    }
}


<bean id="createBeanFactory" class="com.lagou.edu.factory.CreateBeanFactory">bean>
<bean id="connectionUtils" factory-bean="createBeanFactory" factory-method="getInstance"/>

Bean生命周期

在spring框架管理Bean对象的创建时，Bean对象默认都是单例的，但是它支持配置的方式改变作用范围。
实际开发中用到最多的作用范围就是singleton(单例模式)和 prototype(原型模式，也叫多例模式)。
bean标签属性 scope

单例模式 singleton ：与容器生命周期一致

对象创建：容器创建时，对象也就被创建
对象存活：跟随容器
对象销毁：当容器销毁时，对象也跟着被销毁了

多例模式 prototype：多例模式的bean对象，spring框架只负责创建，不负责销毁

对象创建：当使用对象时，容器创建新的对象实例
对象存活：只要对象在使用中，就一直活着
对象销毁：当对象⻓时间不用时，被java的垃圾回收器回收

Bean标签属性

id : 用于给bean提供一个唯一标识。
class : 用于指定创建Bean对象的全限定类名。
name : 用于给bean提供一个或多个名称。多个名称用空格分隔。
factory-bean : 用于指定创建当前bean对象的工厂bean的唯一标识。当指定了此属性之后， class属性失效。
factory-method : 用于指定创建当前bean对象的工厂方法，如配合factory-bean属性使用，则class属性失效。如配合class属性使用，则方法必须是static的。
scope : 用于指定bean对象的作用范围。
init-method : 用于指定bean对象的初始化方法，此方法会在bean对象装配后调用。必须是一个无参方法。
destroy-method : 用于指定bean对象的销毁方法，此方法会在bean对象销毁前执行。它只能为scope是singleton时起作用。

DI 依赖注入 XML配置

public class JdbcAccountDaoImpl implements AccountDao {

    private ConnectionUtils connectionUtils;
    private String name;
    private int sex;
    private float money;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public void setMoney(float money) {
        this.money = money;
    }


    public JdbcAccountDaoImpl(ConnectionUtils connectionUtils, String name, int sex, float money) {
        this.connectionUtils = connectionUtils;
        this.name = name;
        this.sex = sex;
        this.money = money;
    }

    private String[] myArray;
    private Map<String,String> myMap;
    private Set<String> mySet;
    private Properties myProperties;

    public void setMyArray(String[] myArray) {
        this.myArray = myArray;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyProperties(Properties myProperties) {
        this.myProperties = myProperties;
    }


    public void init() {
        System.out.println("初始化方法.....");
    }

    public void destory(){
        System.out.println("销毁方法.....");
    }
 }

    <bean id="accountDao" class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl" scope="singleton" init-method="init" destroy-method="destory">

        
        
        


 		
        
       
        <constructor-arg name="connectionUtils" ref="connectionUtils"/>
        <constructor-arg name="name" value="zhangsan"/>
        <constructor-arg name="sex" value="1"/>
        <constructor-arg name="money" value="100.6"/>
        

        
        <property name="myArray">
            <array>
                <value>array1value>
                <value>array2value>
                <value>array3value>
            array>
        property>

        <property name="myMap">
            <map>
                <entry key="key1" value="value1"/>
                <entry key="key2" value="value2"/>
            map>
        property>

        <property name="mySet">
            <set>
                <value>set1value>
                <value>set2value>
            set>
        property>

        <property name="myProperties">
            <props>
                <prop key="prop1">value1prop>
                <prop key="prop2">value2prop>
            props>
        property>

    bean>

按照注入的方式分类
1、构造函数注入:利用带参构造函数实现对类成员的数据赋值。
2、set方法注入:通过类成员的set方法实现数据的注入。(使用最多的)
按照注入的数据类型分类
1、基本类型和String：注入的数据类型是基本类型或者是字符串类型的数据。
2、其他Bean类型：注入的数据类型是对象类型，称为其他Bean的原因是，这个对象是要求出现在IoC容器中的。那么针对当前Bean来说，就是其他Bean了。
3、复杂类型(集合类型)：注入的数据类型是Aarry，List，Set，Map，Properties中的一种类型。

需要注意的是：
在List结构的集合数据注入时， array , list , set 这三个标签通用，另外注值的 value 标签内部可以直接写值，也可以使用 bean 标签配置一个对象，或者用 ref 标签引用一个已经配合的bean 的唯一标识。

在Map结构的集合数据注入时， map 标签使用 entry 子标签实现数据注入， entry 标签可以使用key和value属性指定存入map中的数据。使用value-ref属性指定已经配置好的bean的引用。同时 entry 标签中也可以使用 ref 标签，但是不能使用 bean 标签。而 property 标签中不能使用 ref 或者 bean 标签引用对象

XML和注解结合模式开发

引入注解功能，不需要引入额外的jar
由于xml文件依然存在，所以Spring IoC容器的启动仍然从加载xml开始
第三方jar中的bean定义在xml，比如德鲁伊数据库连接池DruidDataSource
自己开发的bean定义使用注解

XML标签与注解的对应关系

XML形式	注解形式
标签	@Component(“XXX”)，注解加在类上
id属性	@Component(“XXX”) 中的value，如果为空，默认bean的id所在类名并且首字母小写;
scope属性	@Scope(“prototype”)，默认单例，注解加在类上
init-method 属性	@PostConstruct，注解加在方法上，该方法就是初始化后调用的方法
destroy-method 属性	@PreDestory，注解加在方法上，该方法就是销毁前调用的方法

DI 依赖注入的注解实现方式

1、@Autowired (推荐使用) 采取的策略为按照类型注入。

public class TransferServiceImpl implements TransferService{
    @Autowired
    private AccountDao accountDao;
}

但是这样又会产生另外一个问题，当一个类型有多个bean值的时候（对接口的多个实现），会造成无法选择具体注入哪一个的情况，这个时候我们需要配合着@Qualifier使用。

public class TransferServiceImpl implements TransferService{
    @Autowired
    @Qualifier(name="jdbcAccountDaoImpl")
    private AccountDao accountDao;
}

2、@Resource 默认按照 ByName 自动注入。
注解由 J2EE 提供，需要导入包 javax.annotation.Resource。因为JDK11 已移除

 
public class TransferService {
    @Resource
	private AccountDao accountDao; 
	
	@Resource(name="studentDao")
	private StudentDao studentDao; 
	
	@Resource(type="TeacherDao")
	private TeacherDao teacherDao; 
	
	@Resource(name="manDao",type="ManDao") 
	private ManDao manDao;
}

如果同时指定了 name 和 type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。
如果指定了 name，则从上下文中查找名称(id)匹配的bean进行装配，找不到则抛出异常。
如果指定了 type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配

纯注解模式开发

实际就是改造XML+注解模式，将XML中遗留的配置全部以注解的形式迁移出去，最终删除XML，从Java配置类启动。

@Configuration 当前类是一个配置类
@ComponentScan 开启注解扫描，替代
@PropertySource，引入外部属性配置文件替代
@Import({ 类名.class , 类名.class… }) 引入其他配置类
@Value 对变量赋值，可以直接赋值，也可以使用 ${} 读取资源配置文件中的信息
@Bean 将方法返回对象加入 SpringIOC 容器

//注解表明当前类是一个配置类
@Configuration

//开启注解扫描，base-package指定扫描的包路径
@ComponentScan({"com.lagou.edu"})

//引入外部资源文件
@PropertySource({"classpath:jdbc.properties"})

//开启spring对注解事物的支持
@EnableTransactionManagement
public class SpringConfig {

    @Value("${jdbc.driver}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;


    @Bean("dataSource")
    public DataSource createDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }

    @Bean("jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    /**
     * 异常：org.springframework.beans.factory.NoSuchBeanDefinitionException:
     *   No qualifying bean of type 'org.springframework.transaction.PlatformTransactionManager' available
     *
     * 原因：因为本事务管理器的类是基于jdbc连接来管理事务，所以在此要注处一个和SqlSessionFactory使用的相同数据源对象
     */

    @Bean("transactionManager")
    public PlatformTransactionManager createTransactionManger(DataSource dataSource){
        return  new DataSourceTransactionManager(dataSource);
    }

IoC高级特性

1、lazy-Init 延迟加载（一定程度上提高容器启动和运转性能，不常使用的 Bean 设置延迟加载，偶尔使用的时候再加载，避免过多占用Bean资源）

也就是Bean的延迟加载(延迟创建)，ApplicationContext 容器的默认行为是在启动服务器时将所有 singleton bean 提前进行实例化。

<bean id="testBean" class="cn.lagou.LazyBean" />


<bean id="testBean" calss="cn.lagou.LazyBean" lazy-init="false" />

lazy-init = “false”，立即加载，表示在spring启动时，立刻进行实例化。
lazy-init = “true” bean将不会在ApplicationContext 启动时提前被实例化，而是第一次向容器通过 getBean索取 bean时实例化的。

如果一个设置了立即加载的 bean1，引用了一个延迟加载的 bean2 ，那么 bean1在容器启动时被实例化，而 bean2由于被bean1引用，所以也被实例化，这种情况也符合延时加载的 bean 在第一次调用时才被实例化的规则。

也可以在容器层次中通过在元素上使用 “default-lazy-init” 属性来控制延时初始化

<beans default-lazy-init="true">
	
beans>

***** 特别注意*****：如果一个 bean 的 scope 属性为 scope=“pototype” 时，即使设置了 lazy-init=“false”，容器启动时也不会实例化bean，而是调用 getBean 方法实例化的。

2、工厂Bean和Bean工厂（FactoryBean / BeanFactory）
BeanFactory接口是容器的顶级接口，定义了容器的一些基础行为，负责生产和管理Bean的一个工厂，具体使用它下面的子接口类型，比如ApplicationContext

Spring中Bean有两种，一种是普通Bean，一种是工厂Bean(FactoryBean)，FactoryBean可以生成某一个类型的Bean实例(返回给我们)，也就是说我们可以借助于它自定义Bean的创建过程。

例子

//Spring提供的工厂Bean接口，可以让我们自定义Bean的创建过程(完成复杂Bean的定义)
public interface FactoryBean<T> {
	@Nullable
	// 返回FactoryBean创建的Bean实例，如果isSingleton返回true，则该实例会放到Spring容器 的单例对象缓存池中Map
	T getObject() throws Exception;
	
	@Nullable
	// 返回FactoryBean创建的Bean类型 
	Class<?> getObjectType();
	
	// 返回作用域是否单例
	default boolean isSingleton() {
	    return true;
  	}
}

//Company类
public class Company {
    private String name;
    private String address;
    private int scale;

    //setter / getter / toString
}

public class CompanyFactoryBean implements FactoryBean<Company> {
	private String companyInfo; // 公司名称,地址,规模
	
	public void setCompanyInfo(String companyInfo) { 
		this.companyInfo = companyInfo;
	}
	
	@Override
    public Company getObject() throws Exception {
		// 模拟创建复杂对象Company
		Company company = new Company();
		String[] strings = companyInfo.split(","); 
		company.setName(strings[0]); 
		company.setAddress(strings[1]); 
		company.setScale(Integer.parseInt(strings[2]));
        return company;
    }
    
	@Override
	public Class<?> getObjectType() { 
		return Company.class;
	}
	
	@Override
	public boolean isSingleton() {
	        return true;
	}
}

<bean id="companyBean" class="com.lagou.edu.factory.CompanyFactoryBean">
	 <property name="companyInfo" value="拉勾,中关村,500"/>
bean>

结果

Object companyBean = applicationContext.getBean("companyBean"); 
System.out.println("bean:" + companyBean);

// 结果如下
bean:Company{name='拉勾', address='中关村', scale=500}

如果是要获取FactoryBean对象，需要在id之前添加“&”

Object companyBean = applicationContext.getBean("&companyBean"); 
System.out.println("bean:" + companyBean);

// 结果如下 
bean:com.lagou.edu.factory.CompanyFactoryBean@43f3f32

3、后置处理器
Spring提供了两种后处理bean的扩展接口 BeanPostProcessor 和 BeanFactoryPostProcessor

在BeanFactory初始化之后可以使用BeanFactoryPostProcessor进行后置处理做一些事情
在Bean对象实例化之后可以使用BeanPostProcessor进行后置处理做一些事情

注意:对象不一定是SpringBean，而SpringBean一定是个对象

BeanPostProcessor ： Bean级别的处理，可以针对某个具体的Bean

public interface BeanPostProcessor {
	//具体这个初始化方法指类似我们在定义bean时，定义了init-method所指定的方法
    @Nullable
    //初始化方法前执行
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    //初始化方法后执行
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

定义一个类实现了BeanPostProcessor，默认是会对整个Spring容器中所有的bean进行处理。
如果要对具体的某个bean处理，可以通过方法参数判断，两个类型参数分别为Object和String，第一个参数是每个bean的实例，第二个参数是每个bean的name或者id属性的值。所以我们可以通过第二个参数，来判断我们将要处理的具体的bean。

注意: 处理是发生在Spring容器的实例化和依赖注入之后。

BeanFactoryPostProcessor ：BeanFactory级别的处理，是针对整个Bean的工厂进行处理

public interface BeanFactoryPostProcessor {

	/**
	 * Modify the application context's internal bean factory after its standard
	 * initialization. All bean definitions will have been loaded, but no beans
	 * will have been instantiated yet. This allows for overriding or adding
	 * properties even to eager-initializing beans.
	 * @param beanFactory the bean factory used by the application context
	 * @throws org.springframework.beans.BeansException in case of errors
	 */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

此接口只提供了一个方法，方法参数为ConfigurableListableBeanFactory，该参数类型定义了一些方法

其中有个方法名为getBeanDefinition的方法，我们可以根据此方法，找到我们定义bean 的 BeanDefinition对象。然后我们可以对定义的属性进行修改

方法名字类似我们bean标签的属性，setBeanClassName对应bean标签中的class属性，所以当我们拿到BeanDefinition对象时，我们可以手动修改bean标签中所定义的属性值。

BeanDefinition对象: 我们在XML中定义的bean标签，Spring解析bean标签成为一个JavaBean( 即 BeanDefinition)

注意: 调用BeanFactoryPostProcessor 方法时，这时候bean还没有实例化，此时 bean 刚被解析成 BeanDefinition对象
##################################################################################################

Spring IoC 源码剖析

Spring源码构建
1、下载源码 spring-framework-5.1.x
2、安装并配置环境变量 Gradle 5.6.3
3、导入项目spring-framework源码（选择 Gradle model）
4、编译顺序: core-oxm-context-beans-aspects-aop

如有疑问可查看详细教程 https://blog.csdn.net/chuanchengdabing/article/details/115330718

Spring IoC容器初始化主体流程

IoC容器是Spring的核心模块，是抽象了对象管理、依赖关系管理的框架解决方案。Spring 提供了很多的容器，其中 BeanFactory 是顶层容器(根容器)，不能被实例化，它定义了所有 IoC 容器必须遵从的一套原则，具体的容器实现可以增加额外的功能，比如我们常用到的ApplicationContext，其下更具体的实现如 ClassPathXmlApplicationContext 包含了解析 xml 等一系列的内容， AnnotationConfigApplicationContext 则是包含了注解解析等一系列的内容。

BeanFactory 容器继承体系

Bean对象创建的几个关键时机点

Spring IoC 容器初始化的关键环节就在 AbstractApplicationContext#refresh() 方法中

 
@Override
public void refresh() throws BeansException, IllegalStateException { 
	synchronized (this.startupShutdownMonitor) {
		// 第一步:刷新前的预处理 prepareRefresh();
		/*
		第二步: 获取BeanFactory;默认实现是DefaultListableBeanFactory
		加载BeanDefition 并注册到 BeanDefitionRegistry
		*/
    	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
		
		// 第三步:BeanFactory的预准备工作(BeanFactory进行一些设置，比如context的类加 载器等)
		prepareBeanFactory(beanFactory);
		try {
			// 第四步:BeanFactory准备工作完成后进行的后置处理工作 
			postProcessBeanFactory(beanFactory);
			
			// 第五步:实例化并调用实现了BeanFactoryPostProcessor接口的Bean 
			invokeBeanFactoryPostProcessors(beanFactory);
			
			// 第六步:注册BeanPostProcessor(Bean的后置处理器)，在创建bean的前后等执 
			registerBeanPostProcessors(beanFactory);
			
			// 第七步:初始化MessageSource组件(做国际化功能;消息绑定，消息解析); 
			initMessageSource();
			
			// 第八步:初始化事件派发器 
			initApplicationEventMulticaster();
			
			// 第九步:子类重写这个方法，在容器刷新的时候可以自定义逻辑 
			onRefresh();
			
			// 第十步:注册应用的监听器。就是注册实现了ApplicationListener接口的监听器
		    registerListeners();
		    
			/*
			第十一步:
				初始化创建非懒加载方式的单例Bean实例(未设置属性)
					填充属性 
					初始化方法调用(比如调用afterPropertiesSet方法、init-method方法) 
					调用BeanPostProcessor(后置处理器)对实例bean进行后置处
			*/
			finishBeanFactoryInitialization(beanFactory);
			
			/*
			第十二步: 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件
			(ContextRefreshedEvent)
			*/
			finishRefresh();
		}

        .......
	}
}

BeanFactory创建流程

获取BeanFactory子流程的时序图

BeanDefinition加载解析及注册子流程

该子流程涉及到如下几个关键步骤

Resource定位:指对BeanDefinition的资源定位过程。通俗讲就是找到定义Javabean信息的XML文件，并将其封装成Resource对象。
BeanDefinition载入 :把用户定义好的Javabean表示为IoC容器内部的数据结构，这个容器内部的数据结构就是BeanDefinition。
注册BeanDefinition到 IoC 容器

过程分析

1、子流程入口在 AbstractRefreshableApplicationContext#refreshBeanFactory 方法中

2、依次调用多个类的 loadBeanDefinitions 方法 —> AbstractXmlApplicationContext —> AbstractBeanDefinitionReader —> XmlBeanDefinitionReader 一直执行到 XmlBeanDefinitionReader 的 doLoadBeanDefinitions 方法

3、我们重点观察XmlBeanDefinitionReader 类的 registerBeanDefinitions 方法，期间产生了多次重载调用，我们定位到最后一个

此处我们关注两个地方:

createRederContext()，
DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions()

先进入 createRederContext 方法看看, 此处 Spring 首先完成了 NamespaceHandlerResolver 的初始化。

再进入 registerBeanDefinitions 方法中追踪，调用了DefaultBeanDefinitionDocumentReader#registerBeanDefinitions 方法
层层方法进入

至此，注册流程结束，我们发现，所谓的注册就是把封装的 XML 中定义的 Bean信息封装为 BeanDefinition 对象之后放入一个Map中，BeanFactory 是以 Map 的结构组织这些 BeanDefinition 的。

BeanDefinition加载解析及注册时序图

Bean创建流程

通过上边的Bean生命周期关键时机点分析，我们知道Bean创建子流程入口在AbstractApplicationContext#refresh()方法的finishBeanFactoryInitialization(beanFactory) 处

层层调用

lazy-init 延迟加载机制原理

普通 Bean 的初始化是在容器启动初始化阶段执行的，而被lazy-init=true修饰的 bean 则是在从容器里第一次进行context.getBean() 时进行触发。Spring 启动的时候会把所有bean信息(包括XML和注解)解析转化成Spring能够识别的BeanDefinition并存到Hashmap里供下面的初始化时用，然后对每个 BeanDefinition 进行处理，如果是懒加载的则在容器初始化阶段不处理，其他的则在容器初始化阶段进行初始化并依赖注入。

DefaultListableBeanFactory.java

public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		// 所有beanDefinition集合
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			// 获取bean 定义
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 判断是否是懒加载单例bean，如果是单例的并且不是懒加载的则在容器创建时初始化
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					/*
						如果是普通bean则进行初始化并依赖注入
						此getBean(beanName)接下来触发的逻辑和懒加载时context.getBean("beanName") 所触发的逻辑是一样的 
					*/
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

Spring IoC循环依赖问题

1、循环依赖 ：循环引用，也就是两个或者两个以上的 Bean互相持有对方，最终形成闭环。比如A 依赖于B，B依赖于C，C又依赖于A。

注意：这里不是函数的循环调用，是对象的相互依赖关系。循环调用其实就是一个死循环，除非有终结条件。

Spring中循环依赖场景有: 构造器的循环依赖(构造器注入) 和 Field 属性的循环依赖(set注入)

其中，构造器的循环依赖问题无法解决，因为初始化时，构造方法必须要传入对象，而此时对象没有初始化，只能拋出BeanCurrentlyInCreationException 异常，

2、循环依赖处理机制

A、Spring 不支持原型 bean 的循环依赖

单例 bean 构造器参数循环依赖(无法解决)
prototype 原型 bean循环依赖(无法解决)

如果这个原型bean正在被创建则直接抛出异常。原型bean在创建之前会进行标记这个beanName正在被创建，等创建结束之后会删除标记

B、单例bean通过setXxx或者@Autowired进行循环依赖

其中原理是依据基于 Java 的引用传递，当获得对象的引用时，对象的属性是可以延后设置的，但是构造器必须是在获取引用之前

其实是通过提前暴露一个ObjectFactory对象来完成的，简单来说ClassA在调用构造器完成对象初始化之后，在调用ClassA的setClassB方法之前就把ClassA实例化的对象通过ObjectFactory提前暴露到Spring容器中。

ClassA调用setClassB方法，Spring首先尝试从容器中获取ClassB，此时ClassB不存在Spring 容器中；
此时，Spring容器初始化ClassB，同时也会将ClassB提前暴露到Spring容器中；
ClassB调用setClassA方法，Spring从容器中获取ClassA ，因为第一步中已经提前暴露了ClassA，因此可以获取到ClassA实例，ClassA通过spring容器获取到ClassB，完成了对象初始化操作。
这样ClassA和ClassB都完成了对象初始化操作，解决了循环依赖问题。

Spring AOP 应用

本质:在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往是权限校验代码、日志代码、事务控制代码、性能监控代码等。

1、AOP术语

在讲解AOP术语之前，我们先来看一下下面这两张图

上图描述的就是未采用AOP思想设计的程序，当我们红色框中圈定的方法时，会带来大量的重复劳动。程序中充斥着大量的重复代码，使我们程序的独立性很差。而下图中是采用了AOP思想设计的程序，它把红框部分的代码抽取出来的同时，运用动态代理技术，在运行期对需要使用的业务逻辑方法进行增强。

Joinpoint(连接点) ：它指的是那些可以用于把增强代码加入到业务主线中的点，那么由上图中我们可以看出，这些点指的就是方法。在方法执行的前后通过动态代理技术加入增强的代码。在Spring框架AOP思想的技术实现中，也只支持方法类型的连接点。
方法开始时、结束时、正常运行完毕时、方法异常时等这些特殊的时机点，我们称之为连接点，项目中每个方法都有连接点，连接点是一种候选点
Pointcut(切入点)：它指的是那些已经把增强代码加入到业务主线进来之后的连接点。由上图中，我们看出表现层 transfer 方法就只是连接点，因为判断访问权限的功能并没有对其增强。
指定AOP思想想要影响的具体方法是哪些，描述感兴趣的方法
Advice(通知/增强) ：它指的是切面类中用于提供增强功能的方法。并且不同的方法增强的时机是不一样的。比如，开启事务肯定要在业务方法执行之前执行;提交事务要在业务方法正常执行之后执行，而回滚事务要在业务方法执行产生异常之后执行等等。那么这些就是通知的类型。其分类有:前置通知后置通知异常通知最终通知环绕通知。
第一个层次:指的是横切逻辑
第二个层次:方位点(在某一些连接点上加入横切逻辑，那么这些连接点就叫做方位点，描述的是具体的特殊时机)
Target(目标对象)：它指的是代理的目标对象。即被代理对象。
Proxy(代理) ：它指的是一个类被AOP织入增强后，产生的代理类。即代理对象。
Weaving(织入)：它指的是把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
Aspect(切面) ：它指定是增强的代码所关注的方面，把这些相关的增强代码定义到一个类中，这个类就是切面类。例如，事务切面定义的方法就是和事务相关的，像开启/提交/回滚事务等，不会定义其他与事务无关的方法。上面的案例中TrasnactionManager 就是一个切面。
Aspect切面= 切入点+增强 = 切入点(锁定方法) + 方位点(锁定方法中的特殊时机)+ 横切逻辑

AOP代理选择

Spring 实现AOP思想使用的是动态代理技术
默认情况下，Spring会根据被代理对象是否实现接口来选择使用JDK还是CGLIB。当被代理对象没有实现任何接口时，Spring会选择CGLIB。当被代理对象实现了接口，Spring会选择JDK官方的代理技术，不过我们可以通过配置的方式，让Spring强制使用CGLIB。

AOP配置方式

在Spring的AOP配置中，也和IoC配置一样，支持3类配置方式。

需求:横切逻辑代码是打印日志，希望把打印日志的逻辑织入到目标方法的特定位置(service层transfer方法)

第一类:使用XML配置
引入AOP的jar包

	<dependency> 
		<groupId>org.springframeworkgroupId> 
		<artifactId>spring-aopartifactId> 
		<version>5.1.12.RELEASEversion>
	dependency>
	<dependency>
		<groupId>org.aspectjgroupId> 
		<artifactId>aspectjweaverartifactId> 
		<version>1.9.4version>
	dependency>



<bean id="logUtil" class="com.lagou.utils.LogUtil">bean>




    
    <aop:config>
        <aop:aspect id="logAspect" ref="logUtils">

            
            
            <aop:pointcut id="pt1" expression="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>

            
            
            <aop:before method="beforeMethod" pointcut-ref="pt1"/>
            
            
            
            

            
        aop:aspect>
    aop:config>

在前面提到，Spring在选择创建代理对象时，会根据被代理对象的实际情况来选择的。被代理对象实现了接口，则采用基于接口的JDK动态代理。当被代理对象没有实现任何接口的时候，Spring会自动切换到基于子类的cglib动态代理方式。

但是我们都知道，无论被代理对象是否实现接口，只要不是final修饰的类都可以采用cglib提供的方式创建代理对象。所以Spring也考虑到了这个情况，提供了配置的方式实现强制使用基于子类的动态代理(即cglib的方式)，配置的方式有两种

1、使用aop:config标签配置

<aop:config proxy-target-class="true">

2、使用aop:aspectj-autoproxy标签配置


<aop:aspectj-autoproxy proxy-target-class="true">aop:aspectj- autoproxy>

第二类:使用XML配置
XML 中开启 Spring 对注解 AOP 的支持

  
 <aop:aspectj-autoproxy/>

@Component
@Aspect
public class LogUtils {

    @Pointcut("execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))")
    public void pt1(){

    }

    /**
     * 业务逻辑开始之前执行
     */
    @Before("pt1()")
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("业务逻辑开始执行之前执行.......");
    }

    /**
     * 业务逻辑结束时执行（无论异常与否）
     */
    @After("pt1()")
    public void afterMethod() {
        System.out.println("业务逻辑结束时执行，无论异常与否都执行.......");
    }


    /**
     * 异常时时执行
     */
    @AfterThrowing("pt1()")
    public void exceptionMethod() {
        System.out.println("异常时执行.......");
    }


    /**
     * 业务逻辑正常时执行
     */
    @AfterReturning(value = "pt1()",returning = "retVal")
    public void successMethod(Object retVal) {
        System.out.println("业务逻辑正常时执行......." + retVal);
    }


    /**
     * 环绕通知
     */
//    @Around("pt1()")
    public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知中的before method....");

        Object result = null;
        try{
            // 控制原有业务逻辑是否执行
             result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("环绕通知中的exception method....");
        }finally {
            System.out.println("环绕通知中的after method....");
        }

        return result;
    }

}

第三类：注解模式
去除XML配置，并在配置类中使用如下注解进行替换上述配置

@Configuration
@ComponentScan("com.lagou") 
@EnableAspectJAutoProxy //开启spring对注解AOP的支持 
public class SpringConfiguration {
}

Spring 声明式事务的支持

编程式事务: 在业务代码中添加事务控制代码，这样的事务控制机制就叫做编程式事务
声明式事务: 通过xml或者注解配置的方式达到事务控制的目的，叫做声明式事务

1、事务的四大特性

原子性(Atomicity) ：原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。从操作的⻆度来描述，事务中的各个操作要么都成功要么都失败

一致性(Consistency) ：事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
转账前A有1000，B有1000。转账后A+B也得是2000。
一致性是从数据的⻆度来说的，(1000，1000) (900，1100)，不应该出现(900，1000)

隔离性(Isolation) ：事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，每个事务不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
事务1给员工涨工资2000，但是事务1尚未被提交，员工发起事务2查询工资，发现工资涨了2000块钱，读到了事务1尚未提交的数据(脏读)

持久性(Durability) ：持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

2、事务的隔离级别
不考虑隔离级别，会出现的错误情况

脏读: 一个线程中的事务读到了另外一个线程中未提交的数据。
不可重复读: 一个线程中的事务读到了另外一个线程中已经提交的update的数据(前后内容不一样)
场景:
员工A发起事务1，查询工资，工资为1w，此时事务1尚未关闭
财务人员发起了事务2，给员工A张了2000块钱，并且提交了事务
员工A通过事务1再次发起查询请求，发现工资为1.2w，原来读出来1w读不到了，叫做不可重复读
虚读(幻读):一个线程中的事务读到了另外一个线程中已经提交的insert或者delete的数据(前后条数不一样)
场景: 事务1查询所有工资为1w的员工的总数，查询出来了10个人，此时事务尚未关闭事务2财务人员发起，新来员工，工资1w，向表中插入了2条数据，并且提交了事务，事务1再次查询工资为1w的员工个数，发现有12个人

数据库四种隔离级别:

Serializable(串行化):可避免脏读、不可重复读、虚读情况的发生。(串行化) 最高
Repeatable read(可重复读):可避免脏读、不可重复读情况的发生。(幻读有可能发生) 第二
该机制下会对要update的行进行加锁
Read committed(读已提交):可避免脏读情况发生。不可重复读和幻读一定会发生。第三
Read uncommitted(读未提交):最低级别，以上情况均无法保证。(读未提交) 最低

MySQL的默认隔离级别是:REPEATABLE READ

3、事务的传播行为
事务往往在service层进行控制，如果出现service层方法A调用了另外一个service层方法B，A和B方法本身都已经被添加了事务控制，那么A调用B的时候，就需要进行事务的一些协商，这就叫做事务的传播行为。

PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常⻅的选择。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行
PROPAGATION_MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作

Spring中事务的API

PlatformTransactionManager

 
public interface PlatformTransactionManager {
	  /**
		* 获取事务状态信息
		*/
	  TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
	
		/**
		* 提交事务 
		*/
	  void commit(TransactionStatus status) throws TransactionException;
	  
		/**
		* 回滚事务 
		*/
	  void rollback(TransactionStatus status) throws TransactionException;
}

此接口是Spring的事务管理器核心接口。Spring本身并不支持事务实现，只是负责提供标准，应用底层支持什么样的事务，需要提供具体实现类。此处也是策略模式的具体应用。在Spring框架中，也为我们内置了一些具体策略，
例如:DataSourceTransactionManager , HibernateTransactionManager 等等。
( HibernateTransactionManager 事务管理器在 spring-orm-5.1.12.RELEASE.jar 中)
Spring JdbcTemplate(数据库操作工具)、Mybatis(mybatis-spring.jar)————> DataSourceTransactionManager
Hibernate框架 ——————> HibernateTransactionManager

DataSourceTransactionManager 归根结底是横切逻辑代码，声明式事务要做的就是使用Aop(动态代理)来将事务控制逻辑织入到业务代码

Spring声明式事务配置

pom.xml 导入jar

 
<dependency> 
	<groupId>org.springframeworkgroupId> 
	<artifactId>spring-contextartifactId> 
	<version>5.1.12.RELEASEversion>
dependency>
<dependency>
	<groupId>org.aspectjgroupId> 
	<artifactId>aspectjweaverartifactId> 
	<version>1.9.4version>
dependency>
<dependency>
	<groupId>org.springframeworkgroupId> 
	<artifactId>spring-jdbcartifactId> 
	<version>5.1.12.RELEASEversion>
dependency>
<dependency>
	<groupId>org.springframeworkgroupId> 
	<artifactId>spring-txartifactId> 
	<version>5.1.12.RELEASEversion>
dependency>

第一种：XML配置

    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    bean>
 
    
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg name="dataSource" ref="dataSource"/>
    bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        
        <tx:attributes>
            
            <tx:method name="*" read-only="false" propagation="REQUIRED" isolation="DEFAULT" timeout="-1"/>
            
            <tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
        tx:attributes>
    tx:advice>

    <aop:config>
        
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
    aop:config>

第二种：XML+注解


<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource">property> 
bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

在接口、类或者方法上添加@Transactional注解

@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)

第三种：注解

Spring基于注解驱动开发的事务控制配置，只是需要在Spring 的配置类上添加 @EnableTransactionManagement 注解，用以替换掉xml配置文件中的配置。

@EnableTransactionManagement//开启spring注解事务的支持 
public class SpringConfiguration {
}

##################################################################################################

Spring AOP源码深度剖析

 
@Component
public class LagouBean {
	public void tech(){
		System.out.println("java learning......");
	} 
}

@Component
@Aspect
public class LagouAspect {
	@Pointcut("execution(* com.lagou.*.*(..))") 
	public void pointcut(){
	}
	
	@Before("pointcut()") 
	public void before() {
		System.out.println("before method ......"); 
	}
}

 
/**
* 测试用例:Aop 代理对象创建 
*/
@Test
public void testAopProxyBuild(){ 
	ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
	LagouBean lagouBean = applicationContext.getBean(LagouBean.class); 
	lagouBean.tech();
}

我们发现在 getBean 之前，LagouBean对象已经产生(即在第一行初始化代码中完成)，而且该对象是一个代理对象(Cglib代理对象)，我们断定，容器初始化过程中目标Ban已经完成了代理，返回了代理对象。

1、代理对象创建流程

流程就是用AopProxyFactory创建AopProxy, 再用AopProxy创建代理对象，这里的AopProxyFactory默认是DefaultAopProxyFactory，看他的createAopProxy方法

2、Spring声明式事务控制
@EnableTransactionManagement

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME)
@Documented 
@Import(TransactionManagementConfigurationSelector.class) 
public @interface EnableTransactionManagement {
}

TransactionManagementConfigurationSelector类，这个类又向容器中导入了两个重要的组件

AutoProxyRegistrar

发现最终，注册了一个叫做 InfrastructureAdvisorAutoProxyCreator 的 Bean, 而这个类是 AbstractAutoProxyCreator 的子类，实现了 SmartInstantiationAwareBeanPostProcessor 接口


它实现了SmartInstantiationAwareBeanPostProcessor，说明这是一个后置处理器，而且跟 spring AOP 开启@EnableAspectJAutoProxy 时注册的 AnnotationAwareAspectJProxyCreator实现的是同一个接口，所以说，声明式事务是 springAOP 思想的一种应用
ProxyTransactionManagementConfiguration
ProxyTransactionManagementConfiguration是一个容器配置类，注册了一个组件 transactionAdvisor，称为事务增强器，然后在这个事务增强器中又注入了两个属性: 属性解析器 transactionAttributeSource 和事务拦截器 transactionInterceptor

属性解析器 AnnotationTransactionAttributeSource 部分源码
属性解析器有一个成员变量是annotationParsers，是一个集合，可以添加多种注解解析器 (TransactionAnnotationParser)，我们关注 Spring 的注解解析器，部分源码如下

TransactionInterceptor 事务拦截器，部分源码

事务拦截器实现了MethodInterceptor接口，追溯一下上面提到的 InfrastructureAdvisorAutoProxyCreator后置处理器，它会在代理对象执行目标方法的时候获取其拦截器链，而拦截器链就是这个TransactionInterceptor，这就把这两个组件联系起来;

构造方法传入PlatformTransactionManager(事务管理器)、TransactionAttributeSource(属性解析器)，但是追溯一下上面贴的ProxyTransactionManagementConfiguration的源码，在注册事务拦截器的时候并没有调用这个带参构造方法，而是调用的无参构造方法，然后再调用set方法注入这两个属性，效果一样。

invokeWithinTransaction 方法，部分源码

/**流程分析
@EnableTransactionManagement 注解 

1)通过@import引入了TransactionManagementConfigurationSelector类
它的selectImports方法导入了另外两个类:AutoProxyRegistrar和ProxyTransactionManagementConfiguration 

2)AutoProxyRegistrar类分析
方法registerBeanDefinitions中，引入了其他类，通过AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)引入
InfrastructureAdvisorAutoProxyCreator，它继承了AbstractAutoProxyCreator，是一个后置处理器类

3)ProxyTransactionManagementConfiguration 是一个添加了@Configuration注解的配置类 
    (注册bean)
	注册事务增强器(注入属性解析器、事务拦截器) 
			属性解析器:AnnotationTransactionAttributeSource，内部持有了一个解析器集合Set annotationParsers; 具体使用的是SpringTransactionAnnotationParser解析器，用来解析@Transactional的事务属性 
			事务拦截器:TransactionInterceptor实现了MethodInterceptor接口，该通用拦截会在产生代理对象之前和aop增强合并，最终一起影响到代理对象 
			TransactionInterceptor的invoke方法中invokeWithinTransaction会触发原有业务逻辑调用(增强事务)
*/

你可能感兴趣的:(后端,java,java,spring)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）编程经验分享开发工具服务器 ssh linux
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Low Power概念介绍-Voltage Area 飞奔的大虎
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
uniapp map组件自定义markers标记点以对_ uni-app学习记录 uni-app javascript 前端
需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
笋丁网页自动回复机器人V3.0.0免授权版源码希希分享软希网58soho_cn 源码资源笋丁网页自动回复机器人
笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
Dom 周华华 JavaScript html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
【Spark九十六】RDD API之combineByKey bit1129 spark
1. combineByKey函数的运行机制 RDD提供了很多针对元素类型为(K,V)的API，这些API封装在PairRDDFunctions类中，通过Scala隐式转换使用。这些API实现上是借助于combineByKey实现的。combineByKey函数本身也是RDD开放给Spark开发人员使用的API之一首先看一下combineByKey的方法说明：
msyql设置密码报错：ERROR 1372 (HY000): 解决方法详解 daizj mysql 设置密码
MySql给用户设置权限同时指定访问密码时，会提示如下错误： ERROR 1372 (HY000): Password hash should be a 41-digit hexadecimal number；问题原因：你输入的密码是明文。不允许这么输入。解决办法：用select password('你想输入的密码');查询出你的密码对应的字符串，然后
路漫漫其修远兮吾将上下而求索周凡杨学习思索
王国维在他的《人间词话》中曾经概括了为学的三种境界古今之成大事业、大学问者，罔不经过三种之境界。“昨夜西风凋碧树。独上高楼，望尽天涯路。”此第一境界也。“衣带渐宽终不悔，为伊消得人憔悴。”此第二境界也。“众里寻他千百度，蓦然回首，那人却在灯火阑珊处。”此第三境界也。学习技术，这也是你必须经历的三种境界。第一层境界是说，学习的路是漫漫的，你必须做好充分的思想准备，如果半途而废还不如不要开始。这里，注
Hadoop(二)对话单的操作朱辉辉33 hadoop
Debug： 1、 A = LOAD '/user/hue/task.txt' USING PigStorage(' ') AS (col1,col2,col3); DUMP A; //输出结果前几行示例： (>ggsnPDPRecord(21),,) (-->recordType(0),,) (-->networkInitiation(1),,)
web报表工具FineReport常用函数的用法总结（日期和时间函数）老A不折腾 finereport 报表工具 web开发
web报表工具FineReport常用函数的用法总结（日期和时间函数）说明：凡函数中以日期作为参数因子的，其中日期的形式都必须是yy/mm/dd。而且必须用英文环境下双引号(" ")引用。 DATE DATE(year,month,day):返回一个表示某一特定日期的系列数。 Year:代表年，可为一到四位数。 Month:代表月份。
c++ 宏定义中的##操作符墙头上一根草 C++
#与##在宏定义中的--宏展开 #include <stdio.h> #define f(a,b) a##b #define g(a) #a #define h(a) g(a) int main() { &nbs
分析Spring源代码之，DI的实现 aijuans spring DI 现源代码
(转) 分析Spring源代码之，DI的实现 2012/1/3 by tony 接着上次的讲，以下这个sample [java] view plain copy print
for循环的进化 alxw4616 JavaScript
// for循环的进化 // 菜鸟 for (var i = 0; i < Things.length ; i++) { // Things[i] } // 老鸟 for (var i = 0, len = Things.length; i < len; i++) { // Things[i] } // 大师 for (var i = Things.le
网络编程Socket和ServerSocket简单的使用百合不是茶网络编程基础 IP地址端口
网络编程;TCP/IP协议网络:实现计算机之间的信息共享,数据资源的交换协议:数据交换需要遵守的一种协议,按照约定的数据格式等写出去端口:用于计算机之间的通信每运行一个程序，系统会分配一个编号给该程序，作为和外界交换数据的唯一标识 0~65535 查看被使用的
JDK1.5 生产消费者 bijian1013 java thread 生产消费者 java多线程
ArrayBlockingQueue：一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列检索操作则是从队列头部开始获得元素。 ArrayBlockingQueue的常用方法：
JAVA版身份证获取性别、出生日期及年龄 bijian1013 java 性别出生日期年龄
工作中需要根据身份证获取性别、出生日期及年龄，且要还要支持15位长度的身份证号码，网上搜索了一下，经过测试好像多少存在点问题，干脆自已写一个。 CertificateNo.java package com.bijian.study; import java.util.Calendar; import
【Java范型六】范型与枚举 bit1129 java
首先，枚举类型的定义不能带有类型参数，所以，不能把枚举类型定义为范型枚举类，例如下面的枚举类定义是有编译错的 public enum EnumGenerics<T> { //编译错，提示枚举不能带有范型参数 OK, ERROR; public <T> T get(T type) { return null;
【Nginx五】Nginx常用日志格式含义 bit1129 nginx
1. log_format 1.1 log_format指令用于指定日志的格式，格式： log_format name(格式名称) type(格式样式) 1.2 如下是一个常用的Nginx日志格式： log_format main '[$time_local]|$request_time|$status|$body_bytes
Lua 语言 15 分钟快速入门 ronin47 lua 基础
- - 单行注释 - - [[ [多行注释] - - ]] - - - - - - - - - - - 1. 变量 & 控制流 - - - - - - - - - - num = 23 - - 数字都是双精度 str = 'aspythonstring'
java-35.求一个矩阵中最大的二维矩阵 ( 元素和最大 ) bylijinnan java
the idea is from: http://blog.csdn.net/zhanxinhang/article/details/6731134 public class MaxSubMatrix { /**see http://blog.csdn.net/zhanxinhang/article/details/6731134 * Q35 求一个矩阵中最大的二维
mongoDB文档型数据库特点开窍的石头 mongoDB文档型数据库特点
MongoDD: 文档型数据库存储的是Bson文档-->json的二进制特点：内部是执行引擎是js解释器，把文档转成Bson结构，在查询时转换成js对象。 mongoDB传统型数据库对比传统类型数据库：结构化数据，定好了表结构后每一个内容符合表结构的。也就是说每一行每一列的数据都是一样的文档型数据库：不用定好数据结构，
[毕业季节]欢迎广大毕业生加入JAVA程序员的行列 comsci java
一年一度的毕业季来临了。。。。。。。。正在投简历的学弟学妹们。。。如果觉得学校推荐的单位和公司不适合自己的兴趣和专业，可以考虑来我们软件行业，做一名职业程序员。。。软件行业的开发工具中，对初学者最友好的就是JAVA语言了，网络上不仅仅有大量的
PHP操作Excel – PHPExcel 基本用法详解 cuiyadll PHP Excel
导出excel属性设置//Include classrequire_once('Classes/PHPExcel.php');require_once('Classes/PHPExcel/Writer/Excel2007.php');$objPHPExcel = new PHPExcel();//Set properties 设置文件属性$objPHPExcel->getProperties
IBM Webshpere MQ Client User Issue (MCAUSER) darrenzhu IBM jms user MQ MCAUSER
IBM MQ JMS Client去连接远端MQ Server的时候，需要提供User和Password吗？答案是根据情况而定，取决于所定义的Channel里面的属性Message channel agent user identifier (MCAUSER)的设置。 http://stackoverflow.com/questions/20209429/how-mca-user-i
网线的接法 dcj3sjt126com
一、PC连HUB (直连线)A端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 B端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。二、PC连PC （交叉线）A端：(568A)：白绿，绿，白橙，蓝，白蓝，橙，白棕，棕； B端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。三、HUB连HUB&nb
Vimium插件让键盘党像操作Vim一样操作Chrome dcj3sjt126com chrome vim
什么是键盘党？键盘党是指尽可能将所有电脑操作用键盘来完成，而不去动鼠标的人。鼠标应该说是新手们的最爱，很直观，指哪点哪，很听话！不过常常使用电脑的人，如果一直使用鼠标的话，手会发酸，因为操作鼠标的时候，手臂不是在一个自然的状态，臂肌会处于绷紧状态。而使用键盘则双手是放松状态，只有手指在动。而且尽量少的从鼠标移动到键盘来回操作，也省不少事。在chrome里安装 vimium 插件
MongoDB查询（2）——数组查询[六] eksliang mongodb MongoDB查询数组
MongoDB查询数组转载请出自出处：http://eksliang.iteye.com/blog/2177292 一、概述 MongoDB查询数组与查询标量值是一样的，例如，有一个水果列表，如下所示： > db.food.find() { "_id" : "001", "fruits" : [ "苹
cordova读写文件（1） gundumw100 JavaScript Cordova
使用cordova可以很方便的在手机sdcard中读写文件。首先需要安装cordova插件：file 命令为： cordova plugin add org.apache.cordova.file 然后就可以读写文件了，这里我先是写入一个文件，具体的JS代码为： var datas=null;//datas need write var directory=&
HTML5 FormData 进行文件jquery ajax 上传到又拍云 ileson jquery Ajax html5 FormData
html5 新东西：FormData 可以提交二进制数据。页面test.html <!DOCTYPE> <html> <head> <title> formdata file jquery ajax upload</title> </head> <body> <
swift appearanceWhenContainedIn:(version1.2 xcode6.4) 啸笑天 version
swift1.2中没有oc中对应的方法： + (instancetype)appearanceWhenContainedIn:(Class <UIAppearanceContainer>)ContainerClass, ... NS_REQUIRES_NIL_TERMINATION; 解决方法：在swift项目中新建oc类如下： #import &
java实现SMTP邮件服务器 macroli java 编程
电子邮件传递可以由多种协议来实现。目前，在Internet 网上最流行的三种电子邮件协议是SMTP、POP3 和 IMAP，下面分别简单介绍。　　◆ SMTP 协议　　简单邮件传输协议(Simple Mail Transfer Protocol,SMTP)是一个运行在TCP/IP之上的协议，用它发送和接收电子邮件。SMTP 服务器在默认端口25上监听。SMTP客户使用一组简单的、基于文本的
mongodb group by having where 查询sql qiaolevip 每天进步一点点学习永无止境 mongo 纵观千象
SELECT cust_id, SUM(price) as total FROM orders WHERE status = 'A' GROUP BY cust_id HAVING total > 250 db.orders.aggregate( [ { $match: { status: 'A' } }, { $group: {
Struts2 Pojo（六） Luob. POJO strust2
注意：附件中有完整案例 1.采用POJO对象的方法进行赋值和传值 2.web配置 <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee&q
struts2步骤 wuai struts
1、添加jar包 2、在web.xml中配置过滤器 <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.st

Spring框架

第一部分 Spring概述

1、Spring简介

2、Spring 的优势

3、Spring 核心结构

第二部分 核心思想

1、IoC

2、AOP

第三部分 手写实现 IoC 和 AOP

银行转账案例及代码调用关系

银行转账案例关键代码

代码问题分析

解决思路

代码升级

第四部分 Spring IOC 应用

Spring IoC基础

纯XML模式开发

XML和注解结合模式开发

纯注解模式开发

IoC高级特性

Spring IoC 源码剖析

Spring IoC容器初始化主体流程

BeanFactory创建流程

Bean创建流程

lazy-init 延迟加载机制原理

Spring IoC循环依赖问题

Spring AOP 应用

1、AOP术语

AOP代理选择

AOP配置方式

Spring 声明式事务的支持

Spring中事务的API

Spring声明式事务配置

Spring AOP源码深度剖析

你可能感兴趣的:(后端,java,java,spring)

第二部分核心思想

第三部分手写实现 IoC 和 AOP