SSM框架之Spring框架全面总结

最新推荐文章于 2023-05-22 15:45:38 发布
最新推荐文章于 2023-05-22 15:45:38 发布
阅读量465 收藏 1
点赞数 1
分类专栏： Java框架 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Boring1/article/details/107849622
版权

一、Spring定义

​ Spring六大模块

image-20200417110226125

二、IOC

1、定义

	IOC（Inversion of Control ，即控制反转，它是一种思想。实际上就是指一个对象的创建交由第三方完成，第三方即IOC容器。这种思想的目的是实现对象不用在程序中写死。  

	DI（Dependency Injection）：依赖注入，实现IOC的方式，处理对象和对象之间的依赖关系。	

	无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量，我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。

2、容器说明

​ （1）BeanFactory和 ApplicationContext 的区别

	①BeanFactory是Spring 容器中的顶层接口,ApplicationContext 是它的子接口。 
	②BeanFactory 和 ApplicationContext 的区别:创建对象的时间点不一样。   		   	  
    	ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。 
		BeanFactory：什么使用什么时候创建对象。

​ （2）ApplicationContext 接口的实现类

        ①ClassPathXmlApplicationContext
        它是从类的根路径下加载核心配置文件(推荐使用这种) 

        ②FileSystemXmlApplicationContext
        它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

        ③AnnotationConfigApplicationContext
        当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

​ （3）BeanFactory接口的实现类

	XMLBeanFactory:用这个实现类去创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

image-20200417132513970

3、环境搭建

​ 导入开发包

image-20200417113644231

image-20200417114414037

4、基于XML方式的基本操作

（1）定义核心XML配置文件

	在类根路径下创建，Maven定义在resource文件里。通常命名为：applicationContext.xml或者叫bean.xml

（2）编写核心配置文件

①XML方式的约束头
<?xml version="1.0" encoding="UTF-8"?> 
<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      http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>
②配置文件标签
I、bean标签
{1}定义
	用于配置对象让 spring 来创建的。默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
{2}属性
		  id：对象的唯一标识，可以通过id获取容器中创建的对象。    
		  class：指定要创建对象的全限定类名。 
		  scope：指定对象的作用范围。
           * singleton :默认值，获取到的对象是单例的.    
           * prototype :获取到的对象是多例的.    
           * request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.    
           * session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.    
           * global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么 globalSession 相当于 session. 
 
           * init-method：指定类中的初始化方法名称。  
           * destroy-method：指定类中销毁方法名称。
{3} Bean对象的作用范围和生命周期

​ A、单例对象scope=“singleton” ,一个应用只有一个对象的实例。它的作用范围就是整个引用。

		生命周期：对象出生：当应用加载，创建容器时，对象就被创建了。    
		对象活着：只要容器在，对象一直活着。    
		对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

​ B、多例对象：scope=“prototype” 每次访问对象时，都会重新创建对象实例。

 		生命周期：对象出生：当使用对象时，创建新的对象实例。    
 		对象活着：只要对象在使用中，就一直活着。    
 		对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。
{4}例子
			<!-- 配置 AccountserviceImpl类 -->    
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"> </bean>

（3）获取存储在容器中的对象

​ 基于（2）的{4}例子。

image-20200417124548189

5、常用注解

（1）创建对象的注解

		@Component ：非三层架构用此注解
		@Controller ： 一般用于表现层的注解。 
		@Service  ：一般用于业务层的注解
		@Repository ：一般用于持久层的注解。 
		以上注解的作用与属性是一模一样的，出现这四个注解的原因是赋予其明确的语义化。资源给Spring管理，相当于在 xml 中配置一个 bean。 属性：value：指定 bean 的 id。如果不指定 value 属性，默认 bean的id是当前类的类名。首字母小写。

（2）注入数据的注解

①@AutoWired
		作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。若无与其匹配的，则注入失败，报错。如果Ioc容器中有多个类型匹配时，它首先会按照该变量的类型，去找其与IOC容器匹配的类型的对象，接着通过该变量名称作为bean的id，查找。如果有该id，则注入成功。否则注入失败，报错。
		
		出现位置：可以是变量上，也可以是方法上，给方法参数注入。
		
		细节：在使用注解注入时，set方法就不是必须的了。如果给方法注入，则是给方法参数注入，如果有IOC容器有多个类型与其匹配，则方法参数的变量名要和bean的id相同，不然就会报错。
②@Qualifier
		作用：通过指定的id去获取容器里的对象。它在给成员变量注入时必须要和@Autowire 一起使用；但是给方法的参数注入时，可以独立使用。 
		
		属性:value,指定id获取IOC容器中的bean.

image-20200418140715626

③@Resource
		作用:直接按照Bean的id注入,不需要依赖AutoWired，也就说它是@Qualifier的改良版。它可以给方法参数和成员变量注入.给方法参数注入时，要定义在方法上，和@Qualifier的位置不同.
		
		属性:name,指定id以获取IOC容器的bean.

​ --------------------------------------------------------------------------------------------------------------------------------------

	以上三个注解只能注入其他bean类型，而string和基本类型无法使用。另外，集合类型的注入只能通过XML来实现。
④@Value
		作用： 注入基本数据类型和 String 类型数据的，支持Spring的SEL表达式.${} 
		
		属性：  value：用于指定数据的值

image-20200418114707013

（3）改变bean作用范围

@Scope
 		作用：用于指定bean的作用范围
        
 		属性：value：指定范围的取值。常用取值：singleton单例,prototype多例
 		
 		位置:写于指定Bean的类上.

（4）生命周期相关的

	应用在方法上
① @PostConstruct
		作用：用于指定初始化方法。
②@PreDestroy
		作用：用于指定销毁方法。

6、基于XML与注解混合方式

（1）@Component 注解配置管理的资源

（2）创建 spring 的 xml配置文件并开启对注解的支持

①约束头
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
②开启注解扫描器
 <context:component-scan base-package="包名"></context:component-scan>

（3）具体操作

①设置注解

image-20200417153316466

②开启注解扫描

image-20200417153213655

③获取经过扫描后存储在容器中的对象 image-20200417153148413

image-20200417153346933

7、基于纯注解方式

(1)此方式用到的注解

① @Configuration
  	作用：指定当前类是一个配置类    
  	细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
②@ComponentScan
	作用：用于通过注解指定spring在创建容器时要扫描的包。（扫描的类上要有注解，该注解是能够将类作为bean存入容器中的。个人理解）
  	属性：
  		 ①basePackages
  		 ②value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。
            我们使用此注解就等同于在xml中配置了:
            <context:component-scan base-package="com.itheima"></context:component-scan>
③@Bean
		作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中  
        
		属性: name:用于指定bean的id。当不写时，默认值是当前方法的名称
        
        细节：当我们使用该注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象,如果没有就会报错(包括基本类型和String类型)。查找的方式和Autowired注解的作用是一样的
④@Import
		作用：用于导入其他的配置类
        
		属性：value：用于指定其他配置类的字节码。                  
		当我们使用Import的注解之后，有Import注解的类就是父配置类，而导入的都是子配置类
⑥@PropertySource
		作用：用于指定properties文件的位置  
		
		属性：value,指定文件的名称和路径。  
        
		关键字：classpath，表示在类路径下获取. @PropertySource("classpath:xxx")

（2）具体操作

①定义一个配置类
	可以定义父配置类和子配置类
I、父配置类image-20200418140445226
II、子配置类
		Value注解的SEL表达式使用.从properties配置的key获取值.

image-20200418140909724

image-20200418140943494

②properties

image-20200418141107455

③获取存储在容器中的对象
	纯注解方式使用AnnotationConfigApplicationContext.

image-20200418141152343

image-20200418141215413

8、依赖注入

（1）定义

	Dependency Injection:依赖注入。它是 spring 框架核心 ioc 的具体实现。用于解决对象与对象之间的依赖关系。而对象之间的依赖关系，其实就是给对象上的属性赋值！因为对象上有其他对象的变量，因此存在了依赖。

	例子：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就应该让 spring 来维护。 简单的说，就是坐等框架（采用DI）把持久层对象传入业务层，而不用我们自己去获取。这样做的好处是当我们要换持久层的实现类，无需再修改业务层代码，只需要设置配置文件即可。

（2）能注入类型

   		  ①基本类型和String（直接注入）
   		  ②其他bean类型（在配置文件中或者注解配置过的bean）
   		  ③复杂类型/集合类型

（3）注入方式

①通过构造函数
②通过set方法给属性注入值
③p名称空间
④自动装配(了解)
⑤注解

（4）构造方法注入

①概念
	即通过使用类的构造函数，给成员变量赋值。这个赋值操作是通过配置由Spring框架为我们进行注入。
②标签

​ constructor-arg

​ constructor-arg：出现位置，bean标签的内部

	①指定给构造方法里的哪个属性赋值
		   type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
 		   index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
 		   name：用于指定给构造函数中指定名称的参数赋值（常用）
     ②给属性进行赋值      
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
③具体操作
I、要注入的类

image-20200417143924436

II、配置注入

image-20200417143924436

image-20200417144317393

III、获取

image-20200417144340491

IIII、结果

image-20200417144352849

（5）set方法注入

①概念
	 就是在类中提供需要注入成员的 set 方法
②标签

​ property：用于给set方法注入值，此标签出现在Bean标签内部。

 		name：用于指定注入时所调用的set方法名称，注意这个名称是去Set再将后面的首字母小写。即set方法名称为SetAgeS，则name属性要填写的ageS.
        value：用于提供基本类型和String类型的数据
        ref：用于指定其他的bean类型数据，它指的就是在spring的Ioc核心容器中出现过的bean对象
③具体操作
I、要注入的方法

image-20200417145523308

II、注入

image-20200417145636988

III、获取

image-20200417145656904

IIII、结果

image-20200417145730705

（6）使用 p 名称空间注入

	此种方式是通过在 xml中导入 p名称空间，使用 p:Set方法名称，来注入数据，它的本质仍然是调用类中的 set 方法实现注入功能。优化了set方式配置。
①约束头
<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation=" http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
    </beans>
②具体操作
I、要注入的类

image-20200417151647272

II、注入配置

image-20200417151718746

III、获取执行

image-20200417151730773

IIII、结果

image-20200417151718746

image-20200417151730773

image-20200417151738872

（7）注解注入

跳转到本章的5(2)注入数据的注解

（8）关于集合和数组的注入

	List结构集合注入的标签：list array set   
	Map结构集合注入的标签：map  props    
	结构相同，标签可以互换
①要注入的类

image-20200417150143310

②配置注入

image-20200417150238537

image-20200417150328953

③执行

image-20200417150503310

④结果

image-20200417150516441

9、Spring整合Junit

	为什么要使用Spring整合的Junit?这样子就能自动创建容器.我们就不需要在测试类中创建容器了。

（1）配置步骤

​ ①导入spring整合junit的jar(坐标)

   <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
   </dependency>

​ ②在测试类上写上spring提供的注解

		@Runwith(SpringJUnit4ClassRunner.class)

​ ③告知spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置

		@ContextConfiguration               
		①基于XML：locations：指定xml文件的位置，加上classpath关键字，表示在类路径下         		   ②基于注解: classes：指定注解类所在位置

​ 当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上

（2）具体操作

image-20200418142523831

三、AOP

1、相关术语

（1）Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。(相当于动态代理中的代理对象里的方法) 

（2）Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。(相当于动态代理中代理对象中要进行增强的方法) 

（3）Advice(通知/增强):所谓通知是指拦截到 Joinpoint(方法) 之后所要做的事情就是通知。
	通知类型
		①前置通知
		②后置通知
		③异常通知
		④最终通知
		⑤环绕通知:环绕目标方法执行
	
（4）Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方 法或 Field。 

（5）Target(目标对象):代理的目标对象。 

（6）Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。 

（7）Proxy（代理）:一个类被 AOP 织入增强后，就产生一个结果代理类。 

（8）Aspect(切面):一个类，里面都是通知

​

2、基于XML的AOP

（1）XML文件配置步骤

 	1、把通知类用bean标签配置起来 
 	
    2、使用aop:config声明aop配置 
    
    3、在aop:config内使用aop:aspect标签配置切面
          id属性：是给切面提供一个唯一标识
          ref属性：是指定通知类bean的Id。
          
    4、在aop:aspect标签的内部使用对应标签来配置通知的类型
          ①aop:before：表示配置前置通知
             method属性：用于指定Logger类中哪个方法是前置通知
             pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
			point-ref属性:表示引入外部切入点表达式
          ②aop:after-returning:后置通知 
          ③aop:after-throwing:异常通知
          ④aop:after:最终通知

（2）具体操作

①导入Jar坐标
  <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>
②核心配置文件的约束
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>
③核心配置文件内容

​ I、配置要增强的对象

​ II、配置进行通知的类的对象

​ III、配置切面，进行通知与切入点的联系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>


    <!-- 配置Logger类 -->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型，此标签为前置通知，并且建立通知方法和切入点方法的关联-->
			<!--通过方法method是Logger类有的方法，pointcut是指定切入点方法,用了切入点表达式-->
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

</beans>
④额外篇：切入点表达式写法
	  I、关键字：execution(表达式)
	  II、表达式：访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
	  III、标准的表达式写法：
	public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
     		①访问修饰符可省略
          
    		②返回值可以使用通配符*，表示任意返回值. 
          
   			③包名
    			A、包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    void *.*.*.*.AccountServiceImpl.saveAccount())
    			B、包名也可以使用..表示当前包及其子包
                    void *..AccountServiceImpl.saveAccount()
          
   			④ 类名和方法名都可以使用*来实现通配
          
   			⑤ 参数列表：
    			A、可以直接写数据类型：
                      基本类型直接写名称           int
                      引用类型写包名.类名的方式   java.lang.String
    			B、可以使用通配符*表示任意类型,但是必须有参数
    			C、可以使用..表示有无参数均可,有参数可以是任意类型.
          
   			⑥ 全通配写法：
                    * *..*.*(..)
          
   			⑦ 实际开发中切入点表达式的通常写法：
                 切到业务层实现类下的所有方法   * com.itheima.service.impl.*.*(..)
⑤具体类内容

image-20200418154127062

		要被增强的類

image-20200418153905123

		切面

image-20200418153915991

⑥测试 image-20200418154146941

image-20200418154026745

3、基于XML的AOP四种通知

（1）类

image-20200418155454060

image-20200418155507250

（2）非环绕通知

	非环绕通知有一个问题，就是执行顺序问题.如果把把前置通知和后置通知位置互换，则执行顺序也会不同，就会先执行后置通知，接着执行目标方法，再执行后置通知。而环绕通知就不会有这种问题。
①核心文件配置

​ image-20200418155116705

image-20200418155340086

②Logger类

image-20200418155443169

③测试

image-20200418155528541

④结果

image-20200418155545853

（3）环绕通知

 	Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
  	spring中的环绕通知：它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
①核心配置

image-20200418155908913

②Logger类

​ image-20200418160636303

③执行及结果image-20200418160708342

image-20200418160718300

5、基于非纯注解的AOP步骤

（1）jar包

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

（2）核心文件约束头

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

（3）核心文件内容配置

    <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="XXX"></context:component-scan>

    <!-- 配置spring开启注解AOP的支持 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

（4）配置切面类

​ ①所需注解

	① @Aspect:用于表示当前类是一个切面类
	② @Pointcut:指定切入点表达式，value：指定表达式的内容("execution()")
	③ @Before:前置通知，value：用于指定切入点表达式，还可以指定切入点表达式的引用
	④ @AfterReturning:后置通知，value：用于指定切入点表达式，还可以指定切入点表达式的引用
	⑤ @AfterThrowing:异常通知，value：用于指定切入点表达式，还可以指定切入点表达式的引用
	⑥ @After("pt1()"):最终通知，value：用于指定切入点表达式，还可以指定切入点表达式的引用
	⑦ @Around("pt1()"):环绕通知，value：用于指定切入点表达式，还可以指定切入点表达式的引用

（5）测试

6、基于非纯注解AOP具体操作

（1）配置文件

image-20200419111424254

（2）二选一去执行

①非环绕通知

image-20200419111901908

②环绕通知的情况

image-20200419112107654

（3）执行

image-20200419111934041

image-20200419112026682

四、Spring声明式事务控制

1、XML事务控制配置

（1）Spring事务控制所需约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

（2）步骤

    1、配置事务管理器
            配置事务管理器前要有数据源.
    2、配置事务的通知 
       使用tx:advice标签配置事务通知
          属性：
            id：给事务通知起一个唯一标识
            transaction-manager：给事务通知提供一个事务管理器引用
    3、配置事务的属性
         在事务通知tx:advice标签内部
    4、配置AOP中的通用切入点表达式
    5、建立事务通知和切入点表达式的对应关系

（3）具体实现

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置业务层-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 配置数据源，这里使用Spring提供的JDBC :org.springframework.jdbc.datasource-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置事务的通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 配置事务的属性
                isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
                propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
                read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
                timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
                rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
                no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
        -->
        <tx:attributes>
            <!--*通配符-->
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
        </tx:attributes>
    </tx:advice>

    <!-- 配置aop-->
    <aop:config>
        <!-- 配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--建立切入点表达式和事务通知的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>
</beans>

2、非纯注解事务控制配置

（1）xml约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

（2）具体步骤

 	1、在XML内配置
        ①配置事务管理器
        ②开启spring对注解事务的支持
 	2、在类上方法配置 
    3、在需要事务支持的地方使用@Transactional注解
        ①此注解写在类上，则说明该类的所有方法都有了事务控制
        ②如果写在方法上，则说明只有该方法有事务控制
        ③如果类上，方法上有，且属性不一样，则方法上的注解会覆盖掉类上的注解。

（3）具体操作

①XML文件内部编写

   <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>
	...省略了不必要的代码
    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>

        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>

        <property name="username" value="root"></property>
 
        <property name="password" value="1234"></property>
    </bean>
    
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    
    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
②写上注解

image-20200419161451762

3、纯注解事务控制配置

①获取数据源

image-20200419162135330

②配置事务管理器对象

image-20200419161957413

③写上Transactional注解

nent-scan base-package=“com.itheima”></context:component-scan>
…省略了不必要的代码

    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>

    <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>

    <property name="username" value="root"></property>

    <property name="password" value="1234"></property>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>


<!-- 开启spring对注解事务的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>


##### 			②写上注解

[外链图片转存中...(img-epPnn8w2-1596718697518)]

## 3、纯注解事务控制配置

##### 		①获取数据源

[外链图片转存中...(img-fRZXpyxF-1596718697519)]

##### 		②配置事务管理器对象

[外链图片转存中...(img-E5u3qG1s-1596718697520)]

##### 		③写上Transactional注解

![image-20200419162428768](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vYm9yaW5nTGlmZS9waWMvcmF3L21hc3Rlci9pbWcvaW1hZ2UtMjAyMDA0MTkxNjI0Mjg3NjgucG5n?x-oss-process=image/format,png)
Mr_Boring1
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM框架spring篇
Aa112233aA1的博客
06-18 596
SSM框架概念：由 Spring+ Spring MVC + MyBatis 三大框架组成，SSM 框架是继 SSH 之后，广泛用于软件开发中的 JAVAEE 企业级框架，该框架适用于各种平台各个领域的企业级软件开发，是当前软件开发中最热门的框架。 SSM框架整合思路 1.那什么是Spring？ Spring概念：是由Rod Johnson组织和开发的一个分层的JavaSE/EE full-stack（一站式）轻量级开源框架，它以IoC（Inversion of Control 控制反转）和AOP（Asp
SSM框架之--spring(一)
qq_34283987的博客
11-30 304
一、why–为什么用spring?1.spring框架为我们提供了很多现成的功能（IoC、AOP、声明式事务等、SpringMVC等），这些功能可以直接拿来用、提高开发效率。 2.进一步提高软件产品的质量 框架是前人对软件开发经验的总结，相当于站在巨人的肩膀上，让一个普通的程序员也能写出高质量的软件成品（符合软件工程的规范，例如高内聚 低耦合、OCP等）不用框架 做小的项目没问题，但是做大的项目
ssm框架之spring框架（诞生发展、版本、八大模块、特点、搭建）
快乐学习
02-03 2208
早期的J2EE（Java EE平台）推崇以EJB为核心的开发方式，但是这种开发方式有很多的弊端。并且spring所需的处理开销也是微不足道的。BeanFactory：是工厂模式的一个实现，是任何spring应用的核心。（3）spring为简化开发而生，让程序员只需关注核心业务的实现，尽可能的不再去关注非逻辑业务代码（事务控制、安全日志等等）spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给spring管理。最新的版本已经到了6.0的版本了，最低要求也要为JDK17。搭建运行spring程序
SSM框架(Spring,SpringMVC,MyBatis)
c1210283911的博客
01-31 1106
Spring相关的内容整理,后面继续补充
SSM框架之Spring
尝胆的世界
03-11 374
认识spring Spring是一个轻量级的 控制反转(IOC) 和面向切面编程(AOP) 的容器框架 轻量级：从大小与开销两方面 都是轻量级的。spring框架的jar 很小，运行spring框架的开销很小 非入侵：在代码开发中，一般不会入侵spring代码 控制反转(IOC)：把对象的创建权利交给了容器。 面向切面编程(AOP)： 为什么使用spring框架： 降低组件...
第四篇：SSM框架（Spring、SpringMVC、Mybatis）
xnninger的博客
12-21 1185
一. Spring 1. 简单说一下Spring Spring是一个轻量级java开发框架，简化了java开发。Spring有两大核心，IOC和AOP。 IOC是控制反转，把对象交给Spring来管理。IOC支持依赖注入（DI），可以动态的给一个对象注入它需要依赖的对象。 AOP是面向切面编程，横向抽取公共逻辑，封装成模块。可用于权限控制，日志处理等。 2. IOC是怎么实现的？todo 解析配置文件或扫描配置包下的@Controller@Service@Component等注解，然后......
SSM框架：Spring框架
AI_drag0n的博客
01-18 628
1.Spring简介： Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。 1.AOP编程（动态代理）：日志监控、性...
SSM框架-Spring(一)
weixin_46051964的博客
11-13 1246
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。Spring最初的出现是为了解决EJB臃肿的设计，以及难以测试等问题。Spring为简化开发而生，让程序员只需关注核心业务的实现，尽可能的不再关注非业务逻辑代码（事务控制，安全日志等）。
【SSM框架】一、Spring
xitianxiaofeixue的博客
05-10 175
【SPRING】 一、目前存在的问题 如果直接使用new的形式，如果接口换了，那么这个service要不要重新编译，重新测试，重新部署，重新发布。就会导致我们的代码耦合度偏高。 解决方案为，在使用对象时，程序不要主动使用new产生对象，转换为由外部提供对象（IOC控制反转）–》主要目的就是解耦。 spring对ioc思想进行了实现，提供了一个容器，称为ioc容器。它把它管理的对象统称为Bean。 依赖注入：把service需要的dao对象进行注入，最终的效果是所有的的依赖关系已经帮你绑定好了。 二、
IOC和AOP的理解
春哥团队技术博客
09-16 2922
IOC:控制反转也叫依赖注入。利用了工厂模式 将对象交给容器管理，你只需要在spring配置文件总配置相应的bean，以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，spring会把你在配置文件中配置的bean都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些bean分配给你需要调用这些bean的类（假设这个类名是A），分配的方法就是
SSM框架之Spring入门(详细简单教程 入门必看)
m0_48972623的博客
12-08 306
一、Spring框架是什么 Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IOC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。 提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。 二、Spring
SSM框架-Spring(三)
weixin_46051964的博客
11-22 1148
比如：这里最后一条DML语句之后的睡眠20秒不算进超时时间里。放到insert之前才算。
SSM框架-Spring基础
qq_46263740的博客
11-24 281
SSM框架-Spring基础 1. Spring [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VXZpkdjr-1637715460516)(https://gitee.com/code-once/ImgCloud/raw/master/img/202111121559157.svg)] 1.1 Spring是什么 由Rod Johnson创建的一个开源框架 Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以 IoC （inverse Of
第五--SSM框架(Spring ,SpringMvc, Mybatis)
ldafang的博客
01-29 235
ssm
SSM框架之Spring框架超详解（part two）
qq_52397731的博客
11-18 710
Spring框架（第二部分） 由于第一部分的配置变得十分繁琐，那么有无更好的方式解决问题？使用Spring中的aop实现。 1 AOP的具体应用 1.1 AOP的概念 在软件业，AOP为Aspect Oriented Programming 的缩写，意为：面向切面编程，通过编译方式和运行期动态代理实现程序功能的一种技术。AOP是oop的延续，是软件开发的一个热点，也是spring框架中的一个重要内容。是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑中的各个部分进行隔离，从而使业务逻辑的各部分之间的耦合度
spring
bakun74771的专栏
05-11 167
一、Spring是什么？ Spring是一个开源的轻量级的Java开发框架。 二、Spring有什么作用？ 简化应用程序的开发。 三、简化应用程序开发体现在哪些方面？ ①IOC容器 Java思想是面向对象的开发，一个应用程序是由一组对象通过相互协作开发出的业务逻辑组成，那么如何管理这些对象，使他们高效地...
SSM框架-Spring的学习
最新发布
qq_52699757的博客
05-22 746
​ Spring框架由Rod Johnson开发，2004年发布了Spring框架的第一版。Spring是一个从实际开发中抽取出来的框架，因此它完成了大量开发中的通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高了企业应用的开发效率。低侵入式设计，代码的污染极低。独立于各种应用服务器，基于Spring框架的应用，可以真正实现的承诺。Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦。Spring的AOP。
SSM框架学习笔记（一）简介以及Spring框架介绍
ksws0475000的博客
10-01 1089
SSM框架简介SSM框架是当前的主流框架，既Spring，SpringMVC，Myabits的合称，个人认为，框架的出现是为了是程序员编写代码的时候能够清晰地分辨出每一段代码所代表的意思，以及每一类代码应当处在相同的位置，既为了使得整个程序的架构是清晰而且明确的。我并没有使用过早期的Jsp技术来完成一个网站的制作，但是Jsp技术的兴起与没落同样也是反映出了另一种更普遍或者说是更适应工作要求的技术——
【重温SSM框架系列】1 - Spring快速入门（配置文件及API详解）
1+1=王的博客
02-28 1670
Spring快速入门Spring是什么Spring发展历史Spring的优势Spring的开发步骤没有Spring的时候的开发步骤使用Spring的开发步骤Spring配置文件（applicationContext.xml）Spring相关API Spring是什么 百度百科 Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常
SSM框架：Spring、Spring MVC、MyBatis学习
qq_28316065的博客
10-12 598
一、Spring开源框架 Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。 图1.Spring框架的7个模块 1.核心容器：核心容器提供Spring的基本功能。核心容器的主要组件时BeanFactory，BeanFactory使用控制反转IOC
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值