Spring总体曲线图资源-CSDN文库

版权申诉

spring

163 浏览量 2023-07-31 10:42:35 上传评论收藏 129KB PDF 举报

资源推荐

资源详情

资源评论

5.事务

1.概念：在数据库中的多个操作之间，保证要么都成功，要么都不成功。所有的操作像是一个操作一样。它的四大特性：原子性，一致性，持久性，隔离性

2.事务的隔离级别

1.READ_UNCOMMIT TED：读未提交。未解决任何并发问题。

2.READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻

读。

3.REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读

4.SERIALIZABLE：串行化。不存在并发问题

3.mysql和oracle数据库的隔离级别

MySql 的默认

为 REPEAT ABLE_READ

Oracle默认

为 READ_COMMI T T ED

面试点

4.事务的传播特性

1.PROPAGAT ION_REQUI RED：必被包含事务

2.PROPAGATION_REQUIRES_NEW：自己新开事务，不管之前是否有事务

3.PROPAGAT ION_SUPPORT S：支持事务，如果加入的方法有事务，则支持事务，如果没有，不单开事

务

4.PROPAGATION_NEVER：不能运行中事务中，如果包在事务中，抛异常

5.PROPAGATION_NOT _SUPPORTED：不支持事务，运行在非事务的环境

不常用

6.PROPAGATION_MANDATORY：必须包在事务中，没有事务则抛异常

7.PROPAGATION_NEST ED：嵌套事务

5.xml配置文件的方式声明事务

</bean>

<tx:method name="get*" read-only="true" />

<tx:method name="select*" read-only="true"/>

<tx:method name="find*" read-only="true"/>

<tx:method name="search*" read-only="true"/>

<tx:method name="insert*" propagation="REQUIRED"></tx:method>

<tx:method name="add*" propagation="REQUIRED"></tx:method>

<tx:method name="save*" propagation="REQUIRED" no-rollback-for="ArithmeticException"></tx:method>

<tx:method name="set*" propagation="REQUIRED"></tx:method>

<tx:method name="update*" propagation="REQUIRED"></tx:method>

<tx:method name="modify*" propagation="REQUIRED"></tx:method>

<tx:method name="change*" propagation="REQUIRED"></tx:method>

<tx:method name="delete*" propagation="REQUIRED"></tx:method>

<tx:method name="remove*" propagation="REQUIRED"></tx:method>

<tx:method name="clear*" propagation="REQUIRED"></tx:method>

<tx:method name="empty*" propagation="REQUIRED"></tx:method>

</tx:at t ributes>

</tx:advice>

<aop:config>

<aop:point cut id="pointcat " expression="e xecut ion(* com.bjpowernode.service.*.*(..))"/>

<aop:advisor advice-re f="txAdvice" pointcut-ref="point cat "></aop:advisor>

</aop:config>

6.注解方式@Transactional

</bean>

7.@Transactional参数详解

@T ransactional(

readOnly = false, t rue则为只读，false读写事务(默认)

timeout = -1, 事务的超时时间不限制(数据库有异常或没有连接上，等待的时间，但还是看连接的数据库是如何

设置的。这是默认设置

noRollbackFor = Arit hmet icExcept ion.class, 设置遇到指定的错误不用回滚。

此处是遇到数学异常不回滚，

noRollbackForClassName = "Arithmet icExcept ion"，直接使用异常的名称

rollbackFor = "Arit hmet icExcept ion.class"，发生此异常，必须回滚

,rollbackForClassName = "Arithmet icExcept ion" 发生此异常，必须回滚

isolation = Isolation.DEFAULT , 事务的隔离级别，数据库的默认

propagation = Propagation.REQUIRED 事务的传播行为

)

1）.只能声明在public的method。原因是spring是通过JDK代理或者CGLIB代理的，生成的代理类，只能处理public方法，注解放在类名称上面，这样你配置

的这个@Transactional 对这个类中的所有public方法都起作用，@Transactional 在方法名上，只对这个方法有作用，同样必须是public的方法。

2）.不能被类内部方法调用。还是因为代理的原因，类内部自调用，不会经过代理类，所以@Transactional不会生效

9.不同的框架使用的事务管理器

1.MyBatis框架的事务管理器

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceT ransactionManager">

</bean>

</bean>

<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

4.AOP面向切面编程

1.概念面向切面编程AOP（Aspect Orient Programming），将公共的通用的功能（业务）集中开发，在使用时再织入的一种技术，底层使用JDK动态代理或

者CGLib动态代理

2.什么是切面：

事务，日志，权限，缓存，检查等这些公共的通用就是切面

3.手写AOP框架

1.拆分的过程

1.业务和切面耦合在一起，没有任何拆分

2.拆分业务和切面，使用子类代理的方式进行处理，拆分了业务和切面

3.使用静态代理的方式进行业务和业务接口的分离，切面依赖耦合

4.分离出业务和切面接口，切面接口和业务的实现，使用静态代理的方式进行处理（具备AOP的模型）

5.分离出业务和切面接口，切面接口和业务接口的实现，使用动态代理的方式进行处理（模拟AOP的模型）

2.总结

1.提取业务接口，使业务更灵活

2.提取切面接口，使切面更灵活

3.分别实现业务和切面的实现口，替换接口的实现类则替换整个功能实现

4.使用了JDK的动态代理，完美的靠向了Spring的AOP的处理模式，实现切面（公供的通用的）与业务的分离。

4.Spring的AOP通知

1.Before通知：在目标方法被调用前调用，涉及接口MethodBeforeAdvice;

2.After通知：在目标方法被调用后调用，涉及接口为AfterReturningAdvice;

3.Throws通知：目标方法抛出异常时调用，涉及接口ThrowsAdvice;

4.Around通知：拦截对目标对象方法调用，涉及接口为MethodInterceptor。

5.AspectJ框架

1.概念：是一个优秀的面向切面的框架，它扩展了java语言，提供了强大的切面实现。易学易用。它是eclipse的开源的项目

2.常用术语

1. 切面(Aspect)

公共的，通用的，非主业务的功能，单独进行开发。例如：日志，事务，权限，检查等。开发完毕后，在主业务调用时动态的织入到主业务

中

2连接点(JoinPoint)

指可以被切面织入的具体的业务方法。就是我们说的目标方法。

buy();

连接点连接业务功能与增强功能的方法

3.切入点(Point Cut )

切入点指一个或多个连接点的集合。包可以是切入点，类可以是具体的切入点，类中的某个方法可以是切入点，切入点指明了切面切入的位置。小心：final

方法不能做切入点。

4.目标对象(Target)

目标对象就是指要被增强的对象。扩展功能的对象。包含主业务逻辑的类的对

象。

5.通知(Advice)

通知表示执行的时机，通知也叫增强。通知来决定切面切入到目标对象的时机，是目标对象的方法执行前切入切面，还是执行后切入切面，还是环绕切入切

面。

总结:切入点决定切入的位置，通知决定切入的时机。

3.切入点表达式

原型：

execut ion(访问权限方法返回值方法声明(参数) 异常类

型)

其中访问权限和异常类型可省略

1.execution(public * *(..))

指定切入点为：任意公共方法。

2.execution(* set*(..))

指定切入点为：任何一个以“set”开始的方法。

3.execution(* com.xyz.service.*.*(..)) com.xyx.service.One.a() .xyx.service.Two.b()

指定切入点为：定义在 service 包里的任意类的任意方法。

4.execut ion(* com.xyz.service..*.*(..)) com.xyz.service.dao.*.*(…) com.xyz .service.impl.*.*(..)

指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“..”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类

5.execut ion(* *..service.*.*(..)) com.service.*.*(..) com.bjpowernode.service.*.*(..)

指定所有包下的 serivce 子包下所有类（接口）中所有方法为切入点

6.execut ion(* *.service .*.*(..)) com.service.*.*(..) oracle.service.*.*(..)

指定只有一级包下的 serivce 子包下所有类（接口）中所有方法为切入点

4.AspectJ的通知

1. @Before:通知

用来指定切入的时机，使用此注解表示在业务方法（目标方法）执行前，切入切面功能，是一个前置通知

1.切面方法的规范

1）.方法的访问权限是public

2）.方法没有返回值

3）.方法名称自定义

4）.方法没有参数，如果有参，也是固定的参数JoinPoint（目标方法）

JoinPoint：如果出现此参数，它必须是第一个位置的参数，其它通知都有这个

参数

2.示例

@Before(value = "execution(* com.bjpowernode.s01.*.*(..))")

public void myAspect(JoinPoint jp){

System.out.println("目标方法的签名："+jp.getSignature());

System.out.println("目标方法的参

数："+ Arrays.toString(jp.getArgs()));

System.out.println("我是前置日志切面功能................");

}

2.@Afte rReturning

此通知为后置通知，在目标方法执行后切入切面的功能，也就是增强功

能。

后置通知得到的目标方法的返回值是通知参数传入的。

1.切面方法的规范

1）.访问权限是public

2）.方法有参数，其参数是目标方法的返

回值

3）.方法名称自定义

4）.没有返回值

2.示例

@AfterReturning(value = "execution(* com.bjpowernode.s02.SomeServiceImpl.*(..))",returning = "res")

public void myAspect(Object res){

//方法的参数传值：值传递和引用传递

//值传递实参的内容不改变，引用传递可改变

//当前的Object res:是引用传递，如果是非String类型，则可改变，是String类型，不可变。

//可不可以对返回值做更改？

//因为我是后置通知，所以目标方法执行结束后再执行切面功能，所以可以得到目标方法的返回值，也可以更改

返回值

String returnRest = "";

if(res != null){

returnRest = ((String)res).toUpperCase();

}

System.out.println("我是后置通知，我在业务方法之后执行,目标方法的返回值处理后----"+returnRest);

}

3.@Around

环绕通知-增强方法有 ProceedingJoinPoint参数

在目标方法执行前后都可以增强功能（事务），它可以直接改变目标方法的返回值。因为在切面方法中直接得到目标方法的返回

值

1.方法定义的规范

1).访问权限是public

2).方法有返回值，此返回值就是目标方法的返回值

3).方法有参数，是ProceedingJoinPoint,这个参数就是目标方法，是JoinPoint

子类

4).方法名称自定义

5).声明异常Throwable

2.示例1：增强访问

示例

@Around(value = "execution(* com.bjpowernode.s03.SomeServiceImpl.*(..))")

public Object myAspect(ProceedingJoinPoint pjp) throws Throwable {

//前增强

System.out.println("我是前置功能增强......................");

//目标方法的调用

String res = (String) pjp.proceed(); //method.invoke()手工调用方法，调用了

doThree()方法

//后增强

System.out.println("我是后置功能增强......................");

return res+"hahaha";

3.示例2：限制访问

//取得参数，进行判断name是否是张三，如果是，则进行功能增强，如果不是则什么都不

做

String res = "";

Object []objs = pjp.getArgs();

if(objs != null && objs.length >1 ){

String name = (String) objs[0];

if("张三".equals(name)){

//可以进行前置功能增强

System.out.println("我是前置功能增强...............");

//目标方法调用

res = (String) pjp.proceed();

//后置功能增强

System.out.println("我是后置功能增强..............");

return res+"----haha";

}else{

System.out.println("无法进行功能增强.......");

}

return null;

}

4.@After 最终通知（了解）

无论目标方法是否抛出异常，该增强均会被执

行。

5.@Pointcut 给切入点表达式起别名（了解）

3.Spring框架的IOC

1.概念：控制反转I oC(Inversion of Cont rol），它是一种思想，由容器集中进行对象和创建和依赖管理。

2.两种创建方式

1.基于xml

1.通过<bean>标签进行对象的创建

示例：

2.赋值有三种方式

1.通过sett er()设值注入

切记：必须要在类中提供se tXXX()方法

1.value属性进行简单类型值注入

2.ref属性进行引用类型值注入

2.通过构造方法注入

切记：类中必须要提供相应的构造方法

1.使用构造方法的参数名称进行赋值

<constructor-arg name="age1" value="22"></constructor-

arg>

<constructor-arg name="name1" value="张三"></constructor-

arg>

<constructor-arg name="school1" ref="school"></constructor-

arg>

</bean>

2.使用构造方法的参数的下标位置进行赋值

<constructor-arg index="1" value="22"></constructor-

arg>

<constructor-arg index="0" value="张三">

</constructor-arg>

<constructor-arg index="2" ref="school">

</constructor-arg>

</bean>

3.不指定任何内容，按当前构造方法的参数的顺序进行赋值

<constructor-arg value="张三"></constructor-arg>

<constructor-arg value="22"></constructor-arg>

<constructor-arg ref="school"></constructor-arg>

</bean>

3.引用类型的自动注入

1.byName: 按照成员变量的名称，在Spring容器中找到相同id的对象，自动进行注入

如果没有相同名称的对象进行注入，则注入失败，注入null值，但不会报错

示例：

</bean>

2.byType : 按照成员变量的类型，在Spring容器中找到同源的对象，自动进行注入

同源：

1）java类中的成员变量的类型与xml文件中bean对象的类型一样

2）java类中的成员变量的类型与xml文件中bean对象的是父(java)子(xml)类型

3）java类中的成员变量的类型与xml文件中bean对象的类型是接口(java)与实现类

(xml)

注意：一种类型只能有一个对象，多于一个对象时，注入报错

2.基于注解

1.切记在spring的配置文件中添加扫描组件：

<context:component-scan base-package="com.bjpowernode.pojo"/>

2.创建对象的注解

@Component :可以创建所有对象，但一般用于除了控制器，业务逻辑，数据访问对象的创建

@Controller: 专门用于进行控制器对象的创建，此对象可以接收用户的请求，并且返回处理结果

@Service: 专门用于进行业务逻辑层对象的创建，此对象可以施加事务的管理，向上给控制器提供数据，向下访问数据访问

层

@Re pository:专门用来进行数据访问层对象的创建，进行数据库中的增删改查操作

3.赋值的注解

@Value:给简单类型（8种基本类型+String）赋值

@Autowired:给引用类型按类型注入，相当于byType .

@Autowired

@Qualifier("myschool")

School school; 两个注解一起使用，表示给引用类型按名称注入，相当于

byName.

3.配置文件拆分

1.原因：因为项目越来越大，功能越来越复杂，多人开发协作开发

2.拆分策略

1.按功能模块进行拆分

applicationContext_user.xml

applicationContext_book.xml

2.按层进行拆分

applicationContext_controller.xml

applicationContext_service.xml

applicationContext_dao.xml

3.整合策略

1.单个文件导入

2.批量导入 <import resource="applicationContext_*.xml">

2.Spring框架的优点

1.轻量级

它的每个jar包都比较小，也就是1M-3M左右，便于在网络上进行部署，速度更

快。

对业务代码零污染。

2.面向接口编程

将项目解耦合。对项目解开后的每个模块独立操作，

面向接口的实现类更换后，整个项目的业务功能进行切

换。

3.面向切面

对于公共的业务（切面）（日志，事务，权限处理，具体本项目的一些公共的功能）集中开发，在使用的时候通过动态代理的方式进行织

入。

4.优化框架并整合框架

它相当于是一个插排，对于其它框架提供优化和整合。使其他框架更易

用。

1.什么是Spring框架

1.是企业级开发的很好的解决方案，功能丰富，是一个容器

2.核心技术是I OC和AOP，统一进行对象的创建和依赖的管理，提取公共的业务集中开发，使用时分别织入

Spring

本内容试读结束，登录后可阅读更多

下载后可阅读完整内容，剩余0页未读，立即下载

评论收藏

内容反馈

版权申诉

Java毕设王

粉丝: 6932
资源: 1083

Spring总体曲线图

建筑施工组织2021-施工总体计划表、曲线图.xls

marSpring-framework-issues:总体问题Spring Framework

Spring事务流程图

Spring2.5架构图

Spring启动完整流程图

struts工作原理图、spring框架结构图、hibernate工作原理图

springsecurity原理流程图.pdf

大数据+springcloud技术架构图

spring ioc和aop原理流程图(详细)

spring执行流程图

SpringSecurity加载流程图.vsdx

springioc加载流程图.pdf

Spring 时序图.png

Spring知识导图笔记.xmind

spring源码UML图

spring事务的底层实现流程图

spring 2.5框架图

Spring MVC 核心流程图

spring ioc以及事物架构图

Java spring技术路线导图

SpringCloud学习总图

安卓期末大作业（AndroidStudio开发），垃圾分类助手app，分为前台后台，代码有注释，均能正常运行

Notepad++安装包

SwitchHosts

微信小程序源码-合集1.rar

2024北森能力测评题库.7z

Java面试八股文2023最新版

ruoyi-vue-pro开发指南PDF下载

ruoyi-vue-pro 芋道源码项目的表结构

最新资源