首页 > 基础资料博客日记

Spring学习总结 + 【手写Spring底层机制核心】

2024-04-09 06:30:03基础资料围观267次

这篇文章介绍了Spring学习总结 + 【手写Spring底层机制核心】，分享给大家做个参考，收藏Java资料网收获更多编程知识

Spring学习总结

Spring基本介绍

Spring 学习的核心内容

1.IOC: 控制反转, 可以管理java 对象

2.AOP : 切面编程

3.JDBCTemplate : 是spring 提供一套访问数据库的技术, 应用性强，相对好理解

4.声明式事务: 基于ioc/aop 实现事务管理

spring价值

Spring 最大的价值，通过配置，给程序提供需要使用的
web 层[Servlet(Action/Controller)]/Service/Dao/[JavaBean/entity]对象,
这个是核心价值所在，也是ioc 的具体体现, 实现解耦.

IOC容器

对比传统模式

传统的开发模式[JdbcUtils / 反射]

1.程序员编写程序, 在程序中读取配置信息

2.创建对象, new Object???() // 反射方式

3.使用对象完成任务

IOC 的开发模式

1、Spring 根据配置文件xml/注解, 创建对象，并放入到容器(ConcurrentHashMap)中,
并且可以完成对象之间的依赖
2、当需要使用某个对象实例的时候, 就直接从容器中获取即可
3、程序员可以更加关注如何使用对象完成相应的业务, (以前是new ... ==> 注解/配置
方式)

Spring底层结构

DI 依赖注入

可以理解成是IOC 的另外叫法.

Spring管理 IOC容器

基于XML配置Bean

通过类型获取Bean

ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
Monster monster = ioc.getBean(Monster.class);

按类型来获取bean, 要求ioc 容器中的同一个类的bean 只能有一个, 否则会抛出异常
NoUniqueBeanDefinitionException
应用场景：比如XxxAction/Servlet/Controller, 或XxxService 在一个线程中只需要一个对象实例(单例)的情况
在容器配置文件(比如beans.xml)中给属性赋值, 底层是通过
setter 方法完成的, 这也是为什么我们需要提供setter 方法的原因

通过构造器获取Bean

按索引index

<bean id="monster02" class="com.spring.beans.Monster">
<constructor-arg value="2" index="0"/>
<constructor-arg value="蜘蛛精" index="1"/>
<constructor-arg value="吐口水" index="2"/>
</bean>

按类型type

<bean id="monster03" class="com.spring.beans.Monster">
<constructor-arg value="3" type="java.lang.Integer"/>
<constructor-arg value="白骨精" type="java.lang.String"/>
<constructor-arg value="白骨鞭" type="java.lang.String"/>
</bean>

通过index 属性来区分是第几个参数

通过type 属性来区分是什么类型(按照顺序)

通过p名称空间配置Bean

<bean id="monster04" class="com.spring.beans.Monster"
p:monsterId="4"
p:name="红孩儿"
p:skill="吐火~"
/>

bean 对象的相互引用

其它含义和前面一样
ref 表示memberDAO 这个属性将引用/指向id = memberDAOImpl 对象

引用/注入其它bean 对象

<bean id="memberServiceImpl" class="com.spring.service.MemberServiceImpl">
<property name="memberDAO" ref="memberDAOImpl"/>
</bean>
<bean id="memberDAOImpl" class="com.spring.dao.MemberDAOImpl"/>

引用/注入内部bean 对象

<bean id="memberServiceImpl02"
class="com.spring.service.MemberServiceImpl">
<property name="memberDAO">
<bean class="com.spring.dao.MemberDAOImpl"/>
</property>
</bean>

引用/注入集合/数组类型

给集合属性注入值

<bean id="master01" class="com.code_study.spring.beans.Master">
<property name="name" value="太上老君"/>
<!-- 给bean 对象的list 集合赋值-->
<property name="monsterList">
<list>
<ref bean="monster03"/>
<ref bean="monster02"/>
</list>
</property>

给bean 对象的map 集合赋值

<property name="monsterMap">
<map>
<entry>
<key>
<value>monsterKey01</value>
</key>
<ref bean="monster01"/>
</entry>
<entry>
<key>
<value>monsterKey02</value>
</key>
<ref bean="monster02"/>
</entry>
</map>
</property>

给bean 对象的properties 集合赋值

<property name="pros">
<props>
<prop key="k1">Java 工程师</prop>
<prop key="k2">前端工程师</prop>
<prop key="k3">大数据工程师</prop>
</props>
</property>

给bean 对象的properties 集合赋值

<property name="pros">
<props>
<prop key="k1">Java 工程师</prop>
<prop key="k2">前端工程师</prop>
<prop key="k3">大数据工程师</prop>
</props>
</property>

给bean 对象的数组属性注入值

<property name="monsterName">
<array>
<value>银角大王</value>
<value>金角大王</value>
</array>
</property>

给bean 对象的set 属性注入值

<property name="monsterSet">
<set>
<ref bean="monster01"/>
<bean class="com.spring.beans.Monster">
<property name="monsterId" value="10"/>
<property name="name" value="玉兔精"/>
<property name="skill" value="钻地洞"/>
</bean>
</set>
</property>
</bean>

bean 配置信息重用(继承)

<bean id="monster10" class="com.hspedu.spring.beans.Monster">
<property name="monsterId" value="10"/>
<property name="name" value="蜈蚣精"/>
<property name="skill" value="蜇人"/>
</bean>

<!-- parent="monster10" 就是继承使用了monster10 的配置信息-->
<bean id="monster11" class="com.hspedu.spring.beans.Monster"
parent="monster10"/>

抽象类

<!-- 当我们把某个bean设置为abstract="true" 这个bean只能被继承，而不能实例化了-->
<bean id="monster12" class="com.hspedu.spring.beans.Monster" abstract="true">
<property name="monsterId" value="12"/>
<property name="name" value="美女蛇"/>
<property name="skill" value="吃人"/>
</bean>

bean 创建顺序

在spring 的ioc 容器, 默认是按照配置的顺序创建bean 对象

如果这样配置，会先创建department01 对象，再创建student01 对象.

<bean id="student01" class="com.hspedu.bean.Student" depends-on="department01"/>
<bean id="department01" class="com.hspedu.bean.Department" />

bean 对象的单例和多例

在spring 的ioc 容器, 在默认是按照单例创建的，即配置一个bean 对象后，ioc 容器只会创建一个bean 实例。
如果,我们希望ioc 容器配置的某个bean 对象，是以多个实例形式创建的则可以通过配置scope="prototype" 来指定

默认是单例singleton, 在启动容器时, 默认就会创建, 并放入到singletonObjects 集合
当设置为多实例机制后, 该bean 是在getBean()时才创建
如果是单例singleton, 同时希望在getBean 时才创建, 可以指定懒加载lazy-init="true" (注意默认是false)
通常情况下, lazy-init 就使用默认值false , 在开发看来, 用空间换时间是值得的, 除非有特殊的要求.
如果scope="prototype" 这时你的lazy-init 属性的值不管是ture, 还是false 都是在getBean 时候，才创建对象.

bean 的生命周期

说明: bean 对象创建是由JVM 完成的，然后执行如下方法

执行构造器
执行set 相关方法
调用bean 的初始化的方法（需要配置）
使用bean
当容器关闭时候，调用bean 的销毁方法（需要配置）

细节：

初始化init 方法和destory 方法, 是程序员来指定
销毁方法就是当关闭容器时，才会被调用.

配置bean 的后置处理器

在spring 的ioc 容器,可以配置bean 的后置处理器
该处理器/对象会在bean 初始化方法调用前和初始化方法调用后被调用
程序员可以在后置处理器中编写自己的代码

1、怎么执行到这个方法?=> 使用AOP(反射+动态代理+IO+容器+注解)

2、有什么用？=> 可以对IOC 容器中所有的对象进行统一处理,比如日志处理/权限的校验/安全的验证/事务管理.

3、针对容器的所有对象吗? 是的=>切面编程特点

通过属性文件给bean 注入值

<context:property-placeholder location="classpath:my.properties"/>
<bean id="monster100" class="com.code_study.spring.beans.Monster">
<property name="monsterId" value="${id}"/>
<property name="name" value="${name}"/>
<property name="skill" value="${skill}"/>
</bean>

基于XML 的bean 的自动装配

<bean id="orderAction" autowire="byName"
class="com.code_study.spring.action.OrderAction"/>
<bean id="orderService" autowire="byName"
class="com.code_study.spring.service.OrderService"/>
<bean id="orderDao" class="com.code_study.spring.dao.OrderDao"/>

特别说明:

autowire = "byName" 会自动去找id 为setXxxx 后面Xxxx 的bean 自动组装.,如果找到就装配，如果找不到就报错,
比如这里的
就会去找OrderAction 类中定义的setOrderService 的id 为orderService 的OrderServicebean 组装，找到就组装，找不到就组装失败

基于注解配置Bean

基本介绍

基于注解的方式配置bean, 主要是项目开发中的组件，比如Controller、Service、和Dao.

组件注解的形式有

@Component 表示当前注解标识的是一个组件
@Controller 表示当前注解标识的是一个控制器，通常用于Servlet
@Service 表示当前注解标识的是一个处理业务逻辑的类，通常用于Service 类
@Repository 表示当前注解标识的是一个持久化层的类，通常用于Dao 类

！！！Spring 的IOC 容器不能检测一个使用了@Controller 注解的类到底是不是一个真正的控
制器。注解的名称是用于程序员自己识别当前标识的是什么组件。其它的@Service
@Repository 也是一样的道理[也就是说spring 的IOC 容器只要检查到注解就会生成对象，
但是这个注解的含义spring 不会识别，注解是给程序员编程方便看的]！！！

自动扫描包

<!-- 配置自动扫描的包，注意需要加入context 名称空间-->
<context:component-scan base-package="com.code_study.spring.component" />

扫描时排除某些类 -expression

<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Service"/>

指定自动扫描哪些注解类

<!--
1. use-default-filters="false": 不再使用默认的过滤机制
2. context:include-filter: 表示只是扫描指定的注解的类
3.expression="org.springframework.stereotype.Controller": 注解的全类名
-->
<context:component-scan base-package="com.code_study.spring.component"
use-default-filters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Service"/>
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

修改beanName

标记注解后，类名首字母小写作为id 的值。也可以使用注解的value 属性
指定id 值，并且value 可以省略

AOP

动态代理

// 1.获取类加载对象
ClassLoader loader = target_obj.getClass().getClassLoader();
// 2.获取接口类型数组
Class<?>[] interfaces = target_obj.getClass().getInterfaces();
// 3.获取InvocationHandler 以匿名内部类的方式方式来获取InvocationHandler
InvocationHandler h = new InvocationHandler() {
// 4.以动态代理的方式调用目标对象的目标方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
String methodName = method.getName();
try {
// 1. 在调用目标方法之前打印“方法开始”日志
System.out.println("日志--方法名：" + methodName + "--方法开始--参数："
+ Arrays.asList(args));
// 2. 调用目标方法并接收返回值
result = method.invoke(target_obj, args);
// 3. 在目标方法结束后打印“方法结束”日志
System.out.println("日志--方法名：" + methodName
+ "--方法正常结束--结果：result=" + result);
} catch (Exception e) {
// 4.如果目标方法抛出异常，打印“方法异常”日志
e.printStackTrace();
System.out.println("日志--方法名：" + methodName
+ "--方法抛出异常--异常类型：" + e.getClass().getName());
} finally {
// 5.在finally 中打印“方法最终结束”日志
System.out.println("日志--方法名：" + methodName + "--方法最终结
束");
}
// 6. 返回目标方法的返回值
return result;
}
};
//生成SmartAnimaleable 的代理对象
//需要三个参数，
//1.就是loader(获取类加载对象)
//2.接口数组
//3.InvocationHandler 对象[这个相对麻烦..]
SmartAnimalable proxy = (SmartAnimalable) Proxy.newProxyInstance(
loader, interfaces, h);
return proxy;
}
}

AOP 的基本介绍

AOP 的全称(aspect oriented programming) ，面向切面编程

在切面类中声明通知方法

前置通知：@Before
返回通知：@AfterReturning
异常通知：@AfterThrowing
后置通知：@After
环绕通知：@Around

细节

关于切面类方法命名可以自己规范一下, 比如showBeginLog() . showSuccessEndLog()
showExceptionLog() , showFinallyEndLog()
切入表达式的更多配置，比如使用模糊配置
@Before(value="execution(* com.code_study.aop.proxy.SmartDog.*(..))")
表示所有访问权限，所有包的下所有有类的所方法，都会被执行该前置通知方法
@Before(value="execution(* .(..))")
当spring 容器开启了
```
 <aop:aspectj-autoproxy/> 
```
, 我们获取注入的对象, 需要以接口的类型来获取, 因为你注入的对象.getClass() 已经是代理类型了!
当spring 容器开启了
```
 <aop:aspectj-autoproxy/> 
```
, 我们获取注入的对象, 也可以通过id 来获取, 但是也要转成接口类型.

开启基于注解的AOP 功能

<aop:aspectj-autoproxy/>

AOP-切入表达式

切入表达式也可以指向类的方法, 这时切入表达式会对该类/对象生效
切入表达式也可以指向接口的方法, 这时切入表达式会对实现了接口的类/对象生效
切入表达式也可以对没有实现接口的类，进行切入

通过JoinPoint 可以获取到调用方法的签名

public void beforeMethod(JoinPoint joinPoint){
joinPoint.getSignature().getName(); // 获取目标方法名
joinPoint.getSignature().getDeclaringType().getSimpleName(); // 获取目标方法所属
类的简单类名
joinPoint.getSignature().getDeclaringTypeName(); // 获取目标方法所属类的类名
joinPoint.getSignature().getModifiers(); // 获取目标方法声明类型(public、private、
protected)
Object[] args = joinPoint.getArgs(); // 获取传入目标方法的参数，返回一个数组
joinPoint.getTarget(); // 获取被代理的对象
joinPoint.getThis(); // 获取代理对象自己
}

AOP-返回通知获取结果

添加属性 returning = "res"

@AfterReturning(value = "execution(public float
com.code_study.spring.aop.joinpoint.SmartDog.getSum(float, float))",
returning = "res")
public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
System.out.println("返回通知" + "--结果是--" + res );
}

AOP-异常通知中获取异常

添加属性 throwing = "throwable"

@AfterThrowing(value = "execution(public float
com.code_study.spring.aop.joinpoint.SmartDog.getSum(float, float))",
throwing = "throwable")
public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
System.out.println("异常通知-- 异常信息--" + throwable);
}

AOP-切入点表达式重用

@Pointcut(value = "execution(public float
com.code_study.spring.aop.joinpoint.SmartDog.getSum(float, float))")
public void myPointCut() {
}

@Before(value = "myPointCut()")
public void showBeginLog(JoinPoint joinPoint) { //前置方法

AOP-切面优先级问题

如果同一个方法，有多个切面在同一个切入点切入，那么执行的优先级如何控制.？

使用：注解@order(value=n) 来控制n 值越小，优先级越高.

AOP输出的信息顺序

不能理解成：优先级高的每个消息通知都先执行，这个和方法调用机制(和Filter 过滤器链式调用类似)

AOP-基于XML 配置AOP

在spring 中，我们也可以通过xml 的方式来配置AOP

<!-- 配置SmartAnimalAspect bean -->
<bean id="smartAnimalAspect"
class="com.code_study.spring.aop.xml.SmartAnimalAspect"/>
<!--配置SmartDog-->
<bean class="com.code_study.spring.aop.xml.SmartDog" id="smartDog"/>
<aop:config>
<!-- 配置统一切入点-->
<aop:pointcut expression="execution(public float
com.code_study.spring.aop.xml.SmartDog.getSum(float, float))"
id="myPointCut"/>
<aop:aspect ref="smartAnimalAspect" order="1">
<!-- 配置各个通知对应的切入点-->
<aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
<aop:after-returning method="showSuccessEndLog"
pointcut-ref="myPointCut" returning="res"/>
<aop:after-throwing method="showExceptionLog"
pointcut-ref="myPointCut" throwing="throwable"/>
<aop:after method="showFinallyEndLog" pointcut-ref="myPointCut"/>
<!-- 还可以配置环绕通知-->
<!-- <aop:around method=""/> -->
</aop:aspect>
</aop:config>
</beans>

JdbcTemplate

JdbcTemplate-基本介绍

通过Spring 可以配置数据源，从而完成对数据表的操作
JdbcTemplate 是Spring 提供的访问数据库的技术。可以将JDBC 的常用操作封装为模板方
法。[JdbcTemplate 类图].

JdbcTemplate创建配置文件

引入外部属性文件

<!-- 引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

配置数据源

<!-- 配置数据源-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.userName}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
</bean>
</beans>

配置JdbcTemplate

<!-- 配置JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- 将上面的数据源分配给jdbcTemplate -->
<property name="dataSource" ref="dataSource"/>
</bean>

JdbcTemplate对数据库的CRUD操作

添加 execute&update

ApplicationContext ioc = new
ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到JdbcTemplate bean
JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
// 1. 添加方式1
// String sql = "INSERT INTO monster VALUES(400, '红孩儿', '枪法厉害')";
// bean.execute(sql);
//2. 添加方式2, 绑定参数
String sql = "INSERT INTO monster VALUES(?, ?, ?)";
int affected = bean.update(sql, 700, "红孩儿2", "枪法厉害2");
System.out.println("add ok affected= " + affected);

修改 update

ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到JdbcTemplate bean
JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
String sql = "UPDATE monster SET skill = ? WHERE id=?";
int affected = bean.update(sql, "美女计", 300);
System.out.println("affected= " + affected);
System.out.println("update data ok~");

批量添加 batchUpdate

ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到JdbcTemplate bean
JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);//添加..
String sql = "INSERT INTO monster VALUES(?, ?, ?)";
List<Object[]> param_list = new ArrayList<Object[]>();
param_list.add(new Object[]{500, "白蛇精", "吃人"});
param_list.add(new Object[]{600, "青蛇精", "吃小孩"});
bean.batchUpdate(sql, param_list);
System.out.println("batch add ok");

查询并封装到Monster 实体对象

ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到JdbcTemplate bean
JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
String sql = "SELECT id as monsterId,name,skill FROM monster WHERE id =?";
//下面这个rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster 对象中.
RowMapper<Monster> rowMapper =
new BeanPropertyRowMapper<Monster>(Monster.class);
Monster monster = bean.queryForObject(sql, rowMapper, 100);

查询并批量封装到Monster 实体对象

ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到JdbcTemplate bean
JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
String sql = "SELECT id as monsterId,name,skill FROM monster WHERE id >=?";
//下面这个rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster 对象中.
RowMapper<Monster> rowMapper = new
BeanPropertyRowMapper<Monster>(Monster.class);
List<Monster> monster_list =
bean.query(sql, rowMapper, 200);
for (Monster monster : monster_list) {
System.out.println(monster);
}

查询单行单列

ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到JdbcTemplate bean
JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
String sql = "SELECT name FROM monster WHERE id =100";
String name = bean.queryForObject(sql, String.class);
System.out.println(name);

使用Map 传入具名参数

1.配置NamedParameterJdbcTemplate,支持具名参数

<bean id="namedParameterJdbcTemplate"
class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<!-- 这里需要使用构造器关联数据源-->
<constructor-arg name="dataSource" ref="dataSource"/>
</bean>

2.使用Map 传入具名参数完成操作

ApplicationContext ioc =
new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到NamedParameterJdbcTemplate bean
NamedParameterJdbcTemplate namedParameterJdbcTemplate =
ioc.getBean(NamedParameterJdbcTemplate.class);
String sql = "INSERT INTO monster VALUES(:my_id, :name, :skill)";
Map<String, Object> map_parameter = new HashMap<String, Object>();
map_parameter.put("my_id", 800);
map_parameter.put("name", "螃蟹精");
map_parameter.put("skill", "钳子无敌大法");
namedParameterJdbcTemplate.update(sql, map_parameter);

使用sqlparametersoruce 来封装具名参数

ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
//得到NamedParameterJdbcTemplate bean
NamedParameterJdbcTemplate namedParameterJdbcTemplate =
ioc.getBean(NamedParameterJdbcTemplate.class);
String sql = "INSERT INTO monster VALUES(:monsterId, :name, :skill)";
Monster monster = new Monster(900, "狐狸精", "狐媚之术");
SqlParameterSource source = new BeanPropertySqlParameterSource(monster);
namedParameterJdbcTemplate.update(sql, source);
System.out.println("add ok~");

声明式事务

使用Spring 的声明式事务处理，可以将一个事务的多个子步骤（sql语句）分别写成一个方法，然后统一管理.
这个是Spring 很牛的地方，在开发使用的很多，优点是无代码冗余，效率高，扩展方便
底层使用AOP (动态代理+动态绑定+反射+注解)

配置声明式事务

引入外部属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>

配置数据源

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.userName}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
</bean>

配置JdbcTemplate

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- 将上面的数据源分配给jdbcTemplate -->
<property name="dataSource" ref="dataSource"/>
</bean>

配置事务管理器

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

开启基于注解的声明式事务功能

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

事务的传播机制

事务传播机制种类

事务传播的属性/种类机制分析，重点 REQUIRED 和REQUIRED_NEW 两种事务

事务的传播机制的设置方法

REQUIRES_NEW 和REQUIRED 在处理事务的策略

如果设置为REQUIRES_NEW
方法2 如果错误，不会影响到Tx1反之亦然，即它们的事务是独立的.
如果设置为REQUIRED 方法2和Tx1是一个整体，只要有方法的事务错误，那么两个方法都不会执行成功.!

事务的隔离级别

默认的隔离级别, 就是mysql 数据库默认的隔离级别一般为REPEATABLE_READ
看源码可知Isolation.DEFAULT 是：Use the default isolation level of the underlying
datastore
查看数据库默认的隔离级别SELECT @@global.tx_isolation

事务的超时回滚

如果一个事务执行的时间超过某个时间限制，就让该事务回滚。
可以通过设置事务超时回顾来实现
使用注解 @Transactional(timeout = 2)

超时时间，设置为2 秒)

手写Spring底层机制

IOC容器

    //定义 BeanDefinitionMap 存放 beanDefinition
    private ConcurrentHashMap<String,BeanDefinition> beanDefinitionMap =
            new ConcurrentHashMap<>();

    //定义 singletonObjects 存放 单例
    private ConcurrentHashMap<String,Object> singletonObjects =
            new ConcurrentHashMap<>();


    //定义beanPostProcessorList 存放 BeanPostProcessor
    private ArrayList<BeanPostProcessor> beanPostProcessorList=
            new ArrayList<>();

构造器

//构造器
public ZyApplicationContext(Class configClass) {
    this.configClass = configClass;

    beanDefinitionsByScan();

    //初始化单例池
    initSingletonObjects();
}

扫描包

private void beanDefinitionsByScan() {
        //获得扫描的包
        ComponentScan componentScan =
                (ComponentScan)this.configClass.getDeclaredAnnotation(ComponentScan.class);

        //获取路径
        String path = componentScan.value();

        path = path.replace(".","/");
        //获取工作路径
        ClassLoader classLoader = ZyApplicationContext.class.getClassLoader();

        URL resource = classLoader.getResource(path);

        File file = new File(resource.getFile());
        if (file.isDirectory()){
            File[] files = file.listFiles();
            for (File f : files) {
                //获取绝对路径
                String fileAbsolutePath = f.getAbsolutePath();
                if (fileAbsolutePath.endsWith(".class")) {
                    //获取className
                    String className = fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));

                    String fullPath = path.replace("/", ".") + "." + className;

                    try {
                        Class<?> clazz = classLoader.loadClass(fullPath);
                        if (clazz.isAnnotationPresent(Component.class)) {

                            //初始化beanPostProcessorList
                            if (BeanPostProcessor.class.isAssignableFrom(clazz)){
                              BeanPostProcessor beanPostProcessor =
                                      (BeanPostProcessor)clazz.newInstance();
                                beanPostProcessorList.add(beanPostProcessor);
                                continue;
                            }


                            //处理className
                            String value = clazz.getDeclaredAnnotation(Component.class).value();
                            if ("".equals(value)){
                                className = StringUtils.uncapitalize(className);
                            }else {
                                className = value;
                            }
                            System.out.println("是一个bean 类名= " + className);
                            //设置 beanDefinition
                            BeanDefinition beanDefinition = new BeanDefinition();
                            //设置scope
                            if (clazz.isAnnotationPresent(Scope.class)){
                                beanDefinition.setScope(clazz.getDeclaredAnnotation(Scope.class).value());
                            }else{
                                beanDefinition.setScope("singleton");
                            }
                            beanDefinition.setClazz(clazz);

                            //放入 beanDefinitionMap
                            beanDefinitionMap.put(className,beanDefinition);




                        } else {
                            System.out.println("不是一个bean 类名= " + className);
                        }
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

初始化单例池

private void initSingletonObjects() {
        Enumeration<String> keys = beanDefinitionMap.keys();
        while (keys.hasMoreElements()){
            String beanName = keys.nextElement();
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            String scope = beanDefinition.getScope();
            if ("singleton".equals(scope)){
                Object bean = createBean(beanDefinition,beanName);
                singletonObjects.put(beanName,bean);
            }

        }
    }

getBean（）

 public Object getBean(String name){
        if (beanDefinitionMap.containsKey(name)){
            BeanDefinition beanDefinition = beanDefinitionMap.get(name);
            String scope = beanDefinition.getScope();
            if ("singleton".equals(scope)){
                return singletonObjects.get(name);
            }else{
                return createBean(beanDefinition,name);
            }
        }
        return null;
    }

createBean()

 private Object createBean(BeanDefinition beanDefinition,String beanName){
        try {
            Class clazz = beanDefinition.getClazz();
            Object instance = clazz.getDeclaredConstructor().newInstance()；
            
            return instance;
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

依赖注入

加入到createBean()中

  private Object createBean(BeanDefinition beanDefinition,String beanName){
        try {
            Class clazz = beanDefinition.getClazz();
            Object instance = clazz.getDeclaredConstructor().newInstance();

            //依赖注入
            Field[] declaredFields = clazz.getDeclaredFields();
            for (Field declaredField : declaredFields) {
                if (declaredField.isAnnotationPresent(Autowired.class)){
                    if (declaredField.getDeclaredAnnotation(Autowired.class).required()){
                        //获的字段名
                        String fieldName = declaredField.getName();
                        //获取实例
                        Object bean = getBean(fieldName);
                        declaredField.setAccessible(true);
                        declaredField.set(instance,bean);
                    }
                }
            }

          
            return instance;
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

后置处理器

加入到createBean()中

  private Object createBean(BeanDefinition beanDefinition,String beanName){
        try {
            Class clazz = beanDefinition.getClazz();
            Object instance = clazz.getDeclaredConstructor().newInstance();

            //依赖注入
            Field[] declaredFields = clazz.getDeclaredFields();
            for (Field declaredField : declaredFields) {
                if (declaredField.isAnnotationPresent(Autowired.class)){
                    if (declaredField.getDeclaredAnnotation(Autowired.class).required()){
                        //获的字段名
                        String fieldName = declaredField.getName();
                        //获取实例
                        Object bean = getBean(fieldName);
                        declaredField.setAccessible(true);
                        declaredField.set(instance,bean);
                    }
                }
            }

            //后置处理器 before()
            //遍历 beanPostProcessorList
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                Object current = beanPostProcessor.
                        postProcessBeforeInitialization(instance, beanName);
                if (current!=null){
                    instance = current;
                }

            }


            //初始化bean
            if (instance instanceof InitializingBean){
                try {
                    ((InitializingBean)instance).afterPropertiesSet();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }



            //后置处理器 after()
            //遍历 beanPostProcessorList
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                Object current = beanPostProcessor.
                        postProcessAfterInitialization(instance, beanName);
                if (current!=null){
                    instance = current;
                }

            }


            System.out.println("");
            System.out.println("-------------------------------------");
            System.out.println("");
            return instance;
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

AOP

AOP需要在后置处理器的before方法中实现

 @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("ZyBeanPostProcessor后置处理器-After-beanName= "+beanName);


        //aop实现

        if("smartDog".equals(beanName)) {
            Object proxyInstance = Proxy.newProxyInstance(ZyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {


                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    Object result = null;

                    if ("getSum".equals(method.getName())) {
                        SmartAnimalAspect.showBeginLog();
                        result = method.invoke(bean, args);
                        SmartAnimalAspect.showBeginLog();
                    }else {
                        result = method.invoke(bean, args);//执行目标方法
                    }

                    return result;
                }
            });
            return proxyInstance;
        }

        return bean;
    }

几个Spring的问题

1.单例/多例怎么实现的？@scope为什么可以实现？

回答：@scope 的value属性可以设置为singleton /prototype

通过getBean（）方法如果bean中的属性scope为singleton 就从单例池直接拿，如果是prototype 就调用createBean（）创建一个实例

2.如何实现依赖注入？@Autowired Spring容器如何实现依赖注入？

回答：遍历clazz的所有属性通过@Autowired注解如果有先获取字段名再通过getBean（）获取对应的bean 最后用filed.set()方法将实例的该属性设置为获取到的bean 实现依赖注入

3.后置处理器为什么在创建bean 时调用bean 的 init方法初始化前/后调用？

//后置处理器 before()
            //遍历 beanPostProcessorList
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                Object current = beanPostProcessor.
                        postProcessBeforeInitialization(instance, beanName);
                if (current!=null){
                    instance = current;
                }

            }


            //初始化bean
            if (instance instanceof InitializingBean){
                try {
                    ((InitializingBean)instance).afterPropertiesSet();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }



            //后置处理器 after()
            //遍历 beanPostProcessorList
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                Object current = beanPostProcessor.
                        postProcessAfterInitialization(instance, beanName);
                if (current!=null){
                    instance = current;
                }

            }

4.后置处理器和AOP有什么关系，Spring Aop如何实现?？

回答：aop的实现实在后置处理器的before中实现的，底层使用动态代理

 //aop实现

        if("smartDog".equals(beanName)) {
            Object proxyInstance = Proxy.newProxyInstance(ZyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {


                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    Object result = null;

                    if ("getSum".equals(method.getName())) {
                        SmartAnimalAspect.showBeginLog();
                        result = method.invoke(bean, args);
                        SmartAnimalAspect.showBeginLog();
                    }else {
                        result = method.invoke(bean, args);//执行目标方法
                    }

                    return result;
                }
            });
            return proxyInstance;
        }

        return bean;

本文学习内容来自韩顺平老师的课程

仅供个人参考学习

文章来源:https://www.cnblogs.com/zydevelop/p/18114318/zy_spring
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！

标签：

上一篇：已解决java.sql.SQLSyntaxErrorException: Unknown database异常的正确解决方法，亲测有效！！！
下一篇：java restful application/x-www-form-urlencoded 传递参数

首页 > 基础资料 博客日记

Spring学习总结 + 【手写Spring底层机制核心】

Spring学习总结

Spring基本介绍

Spring 学习的核心内容

spring价值

IOC容器

对比传统模式

传统的开发模式[JdbcUtils / 反射]

IOC 的开发模式

Spring底层结构

DI 依赖注入

Spring管理 IOC容器

基于XML配置Bean

通过类型获取Bean

通过构造器获取Bean

通过p名称空间配置Bean

引用/注入其它bean 对象

引用/注入内部bean 对象

引用/注入集合/数组类型

bean 配置信息重用(继承)

bean 创建顺序

bean 对象的单例和多例

bean 的生命周期

配置bean 的后置处理器

通过属性文件给bean 注入值

基于XML 的bean 的自动装配

基于注解配置Bean

基本介绍

组件注解的形式有

自动扫描包

扫描时排除某些类 -expression

指定自动扫描哪些注解类

修改beanName

AOP

动态代理

AOP 的基本介绍

在切面类中声明通知方法

开启基于注解的AOP 功能

AOP-切入表达式

通过JoinPoint 可以获取到调用方法的签名

AOP-返回通知获取结果

AOP-异常通知中获取异常

AOP-切入点表达式重用

AOP-切面优先级问题

AOP输出的信息顺序

AOP-基于XML 配置AOP

JdbcTemplate

JdbcTemplate-基本介绍

JdbcTemplate创建配置文件

引入外部属性文件

配置数据源

配置JdbcTemplate

JdbcTemplate对数据库的CRUD操作

添加 execute&update

修改 update

批量添加 batchUpdate

查询并封装到Monster 实体对象

查询并批量封装到Monster 实体对象

查询单行单列

使用Map 传入具名参数

使用sqlparametersoruce 来封装具名参数

声明式事务

配置声明式事务

引入外部属性文件

配置数据源

配置JdbcTemplate

配置事务管理器

开启基于注解的声明式事务功能

事务的传播机制

事务传播机制种类

事务传播的属性/种类机制分析，重点 REQUIRED 和REQUIRED_NEW 两种事务

事务的传播机制的设置方法

REQUIRES_NEW 和REQUIRED 在处理事务的策略

事务的隔离级别

事务的超时回滚

手写Spring底层机制

IOC容器

构造器

扫描包

首页 > 基础资料博客日记