Spring框架的初步深入

最新推荐文章于 2024-05-19 08:30:00 发布

CookieEncore

最新推荐文章于 2024-05-19 08:30:00 发布

阅读量200

点赞数

分类专栏： spring 文章标签： Spring

本文链接：https://blog.csdn.net/weixin_42668719/article/details/82701209

版权

spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Spring框架创建对象的方式有三种：

1.空参构造创建（最常用）：

在Bean标签中添加name属性（用于取对象）class属性（用于让sqring反射），还有一个ID属性现在已经不怎么常用了，他的特点就是不可以重复，不可以有特殊字符

2.静态工厂创建（不常用）：

顾名思义，就是通过工厂模式得到一个对象（静态就是直接调用类方法，不需要创建工厂类），这也被Spring支持，格式就是在Bean标签中添加name属性（用于取对象）class属性（用于让sqring反射）factory-method属性（指定哪个静态方法来创建对象，很重要，没有这个属性，当你使用时Spring会根据空参构造创建的方式给你这个工厂类）

3.实例工厂创建（不常用）：

顾名思义，就是先要得到工厂类，再创建对象，所以，要先配置这个工厂类的空参构造创建，方法一样，就是在Bean标签中指定name属性和class属性，然后，配置你要通过这个工厂得到的实例，就是在Bean标签中添加name属性，factory-method属性，还有factory-methon属性，与静态工厂创建的不同就是把class属性替换成了factory-bean属性，factory-bean中的值也就是你之前配置的工厂的bean中的name属性

Bean标签中的scope属性：

singleton（默认的）：单例的

prototype：多例的，每次在获得时才会创建，每次获得的都是新的对象

request：在web环境下，对象与request的生命周期相同

session：在web环境下，对象与session的生命周期相同

bean中的init-method：

就是前处理方法，也叫生命周期方法，在创建好对象后，立即调用的方法

bean中的destory-method：

后处理方法，在对象销毁之前执行的方法

模块化配置（当bean越来越多时，都写在一个xml中会很难维护，这里就可以使用导入标签，相当于模板的include）：

添加import标签，在resource属性中填写要导入的xml文件

Spring的注入方式有四种：

set方法注入（常用）：

基本类型：创建property标签，并在其中加入name属性（bean的属性名）和value属性（要注入的值）

引用类型：先要把要注入的应用类型配置到xml文件中，创建property标签，并在其中加入name属性（bean的属性名）和ref属性（要注入的bean的name）

构造函数注入：

创建constructor-arg标签，也是和property差不多，基本类型给name,value属性，引用类型给name,ref属性，还可以增加一个index属性，作用就是区分位置，举个例子，两个构造函数的参数(String name,int age),(int age,String name)通过index属性就可以解决这个尴尬，第一个参数是0，第二个是1，跟数组索引差不多，再来个例子，两个构造器(String name,int age),(int name,String age)怎么办，增加type属性，值是引用类型的完整路径

p命名空间注入（很方便，但是因为是后出的，前面那两种已经深入人心并且够用，所以使用的不是很多）：

导入约束（xmlns:p="http://www.springframework.org/schema/p"），然后在bean标签中增加属性（p:属性名="值"）就可以了,引用类型的格式就是（p:属性名-ref="要导入的bean的name"）就可以了，本质走的还是set方式

spel注入：

动态去取值，格式类似于EL表达式就是在value属性上值用#{bean的name属性.property的name属性},只能取基本类型的值

复杂类型注入：

数组类型：要在property标签中加入子标签array，然后在array中加入多个子标签value，子标签value中的test位置填写要注入的值，要注入引用类型就添加多个ref标签，然后在bean属性中（注意这里是属性）填写bean.name

list/set类型：和数组类型一样，把array替换成list/set就行

map类型：要在property标签中加入子标签map，然后添加多个entry，然后分别在key(基本)/key-ref(引用)属性和value(基本类型)/value-ref(引用类型)属性中赋值

property类型：要在property标签中加入子标签peops，然后添加多个peop，key属性添加值，test位置（不是属性）添加值

使用注解配置Spring：

1.导入命名空间

2.设置使用注解，在beans下添加<context:component-scan base-package="使用注解配置的类所在的包名(子孙包也扫描)"></context:component-scan>

3.为类增加注解:

在类前使用@Component("name属性") == <bean name="name属性" class="class位置" />，除了Component以外还有Service（service层），Controller（web层），Repository（dao层），功能完全一样，只是用作分类

在类前使用@Scope(scopeName="prototype|singleton")指定Scope属性

在属性前加上@Value(value="值")==<property name="" value=""></property>(也可以加到set方法前，加在属性前是通过Field反射注入，加在方法前通过set方法赋值·)

给引用类型赋值有如下几个方式：@Autowired标签（自动装配）（单一的bean时使用这个比较方便）如果有多个bean，增加@Qualifier("name")来做区分

@Resource(name="name")直接指定装配哪个类，简言之，bean只有一个使用@Autowired，bean有多个使用 @Resource

@PostConstruct放在方法前，指定为init方法

@PreDestory放在方法前，指定为destory方法

Spring中的AOP：

Spring通过两种方式进行代理，混合使用，第一种是动态代理（要实现接口），第二种通过cglib进行代理（第三方支持，通过继承）

要使用Spring的aop技术，要先准备准备目标对象：

public class UserServiceImpl implements UserService {
	@Override
	public void save() {
		System.out.println("保存用户!");
		//int i = 1/0;
	}
	@Override
	public void delete() {
		System.out.println("删除用户!");
	}
	@Override
	public void update() {
		System.out.println("更新用户!");
	}
	@Override
	public void find() {
		System.out.println("查找用户!");
	}
}

然后准备通知类

//通知类
public class MyAdvice {
	
	//前置通知	
//		|-目标方法运行之前调用
	//后置通知(如果出现异常不会调用)
//		|-在目标方法运行之后调用
	//环绕通知
//		|-在目标方法之前和之后都调用
	//异常拦截通知
//		|-如果出现异常,就会调用
	//后置通知(无论是否出现 异常都会调用)
//		|-在目标方法运行之后调用
//----------------------------------------------------------------
	//前置通知
	public void before(){
		System.out.println("这是前置通知!!");
	}
	//后置通知
	public void afterReturning(){
		System.out.println("这是后置通知(如果出现异常不会调用)!!");
	}
	//环绕通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分!!");
		return proceed;
	}
	//异常通知
	public void afterException(){
		System.out.println("出事啦!出现异常了!!");
	}
	//后置通知
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
}

最后进行织入：

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

<!-- 准备工作: 导入aop(约束)命名空间 -->
<!-- 1.配置目标对象 -->
	<bean name="userService" class="cn.encore.service.UserServiceImpl" ></bean>
<!-- 2.配置通知对象 -->
	<bean name="myAdvice" class="cn.encore.d_springaop.MyAdvice" ></bean>
<!-- 3.配置将通知织入目标对象 -->
	<aop:config>
		<!-- 配置切入点 
			public void cn.itcast.service.UserServiceImpl.save() 准确定位
			void cn.itcast.service.UserServiceImpl.save() public可以省略
			* cn.encore.service.UserServiceImpl.save() 使用通配符表示不对返回值有要求
			* cn.encore.service.UserServiceImpl.*() 使用通配符表示所有方法
			
			* cn.encore.service.*ServiceImpl.*(..) 使用通配符表示所有以ServiceImpl为后缀的类
			* cn.encore.service..*ServiceImpl.*(..)..表示子包也扫描
		-->
		<aop:pointcut expression="execution(* cn.encore.service.*ServiceImpl.*(..))" id="pc"/>
		<aop:aspect ref="myAdvice" >
			<!-- 指定名为before方法作为前置通知 -->
			<aop:before method="before" pointcut-ref="pc" />
			<!-- 后置 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pc" />
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pc" />
			<!-- 异常拦截通知 -->
			<aop:after-throwing method="afterException" pointcut-ref="pc"/>
			<!-- 后置 -->
			<aop:after method="after" pointcut-ref="pc"/>
		</aop:aspect>
	</aop:config>
</beans>

使用注解来配置更简单，只需要准备通知类

package cn.itcast.e_annotationaop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

//通知类
@Aspect
//表示该类是一个通知类
public class MyAdvice {
	@Pointcut("execution(* cn.encore.service.*ServiceImpl.*(..))")
	public void pc(){}
	//前置通知
	//指定该方法是前置通知,并制定切入点
	@Before("MyAdvice.pc()")
	public void before(){
		System.out.println("这是前置通知!!");
	}
	//后置通知
	@AfterReturning("execution(* cn.encore.service.*ServiceImpl.*(..))")
	public void afterReturning(){
		System.out.println("这是后置通知(如果出现异常不会调用)!!");
	}
	//环绕通知
	@Around("execution(* cn.encore.service.*ServiceImpl.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分!!");
		return proceed;
	}
	//异常通知
	@AfterThrowing("execution(* cn.encore.service.*ServiceImpl.*(..))")
	public void afterException(){
		System.out.println("出事啦!出现异常了!!");
	}
	//后置通知
	@After("execution(* cn.encore.service.*ServiceImpl.*(..))")
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
}

Spring进行事务管理的核心就是PlatformTransactionManager接口，他为不同的框架进行了不同的实现（例如HibernateTransactionManager，DataSourceTransactionManager）接口

Spring中事务传播级别有七种：

* 保证同一个事务中：

PROPAGATION_REQUIRED 支持当前事务，如果不存在就新建一个(默认,也是最常用的)

PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务

PROPAGATION_MANDATORY 支持当前事务，如果不存在，抛出异常

* 保证没有在同一个事务中 :

PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务

PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务

PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常

PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行

Spring中配置事务的方式有三种1.编码配置（TrasactionTemplate）（不推荐这种方式不过可搜索相关资料了解，这里不做阐述），2.XML配置，3.注解配置，其实2，3的原理也是通过PlatformTransactionManager来实现

通过XML来进行配置：

<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager" >
	<tx:attributes>
		<!-- 以方法为单位,指定方法应用什么事务属性
			isolation:隔离级别
			propagation:传播行为
			read-only:是否只读
		 -->
		<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
		<tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
		<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
	</tx:attributes>
</tx:advice>
<!-- 配置织入 -->
<aop:config  >
	<!-- 配置切点表达式 -->
	<aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="txPc"/>
	<!-- 配置切面 : 通知+切点
		 	advice-ref:通知的名称
		 	pointcut-ref:切点的名称
	 -->
	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
</aop:config>

通过注解来进行配置：

相对更简单，首先在XML文件中指定使用注解配置

<!-- 开启使用注解管理aop事务 -->
<tx:annotation-driven/>

然后在类中进行注解

@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=true)
//把注解加载这里可以对所有方法进行事务管理，当遇到特殊的方法，比如readOnly=false时，可以再单独配置
public class AccountServiceImpl implements AccountService {

	private AccountDao ad ;
	private TransactionTemplate tt;
	
	@Override
	@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)
	public void transfer(final Integer from,final Integer to,final Double money) {
				//减钱
				ad.decreaseMoney(from, money);
				int i = 1/0;
				//加钱
				ad.increaseMoney(to, money);
	}

CookieEncore

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架的初步深入

Spring框架创建对象的方式有三种：1.空参构造创建（最常用）：在Bean标签中添加name属性（用于取对象）class属性（用于让sqring反射），还有一个ID属性现在已经不怎么常用了，他的特点就是不可以重复，不可以有特殊字符2.静态工厂创建（不常用）：顾名思义，就是通过工厂模式得到一个对象（静态就是直接调用类方法，不需要创建工厂类），这也被Spring支持，格式就是在...
复制链接

扫一扫