多种方式实现依赖注入
构造注入
编写测试类
public class UserServiceImpl implements UserService {
// 声明接口类型的引用,和具体实现类解耦合
private UserDao dao;
// 无参构造
public UserServiceImpl() {
}
// 用于为dao属性赋值的构造方法
public UserServiceImpl(UserDao dao) {
this.dao = dao;
}
public void addNewUser(User user) {
// 调用用户DAO的方法保存用户信息
dao.save(user);
}
}
在使用设值注入时,Spring通过JavaBean无参构造方法实例化对象,当我们编写带参构造方法后,java虚拟机不会再提供默认的无参构造方法,为了保证使用的灵活性,建议自行添加一个无参构造方法
配置文件代码如下:
<?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 ">
<!-- 定义UserDaoImpl对象,并指定id为userDao -->
<bean id="userDao" class="dao.impl.UserDaoImpl" />
<!-- 定义UserServiceImpl对象,并指定id为userService -->
<bean id="userService" class="service.impl.UserServiceImpl">
<!-- 通过定义的单参构造为userService的dao属性赋 值 -->
<constructor-arg>
<!-- 引用id为userDao的对象为userService的dao属性赋值 -->
<ref bean="userDao" />
</constructor-arg>
</bean>
</beans>
1 一个 constructor-arg元素表示构造方法的一个参数，且使用时不区分顺序。
2 通过constructor-arg元素的index 属性可以指定该参数的位置索引，位置从0 开始。
3 constructor-arg元素还提供了type 属性用来指定参数的类型，避免字符串和基本数据类型的混淆。
constructor-arg节点下的四个属性
- index是索引，指定注入的属性，从0开始，如：0代表personDao，1代表str属性；
- type是指该属性所对应的类型，如Persondao对应的是com.aptech.dao.PersonDAO；
- ref 是指引用的依赖对象；
- value 当注入的不是依赖对象，而是基本数据类型时，就用value；
比如:
<bean id="Rod" class="cn.springdemo.Greeting">
<constructor-arg index="1">
<value>Rod</value>
</constructor-arg>
<constructor-arg index="0">
<value>世界上有10种人</value>
</constructor-arg>
</bean>
使用p命名空间实现属性注入
p命名空间的特点:使用属性而不是子元素的形式配置Bean的属性,从而简化了配置代码
语法:
对于直接量（基本数据类型、字符串）属性：p:属性名="属性值"
对于引用Bean的属性：p:属性名-ref="Bean的id"
使用前先要在Spring配置文件中引入p命名空间
xmlns:p="http://www.springframework.org/schema/p"
示例:
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 使用p命名空间注入属性值 -->
<bean id="user" class="entity.User" p:username="皮皮" p:age="21"
p:email="pipi@anxin.com" />
<bean id="userDao" class="dao.impl.UserDaoImpl" />
<bean id="userService" class="service.impl.UserServiceImpl" p:dao-ref="userDao" />
</beans>
注入不同数据类型
注入直接量
使用
注意特殊字符的处理
示例:
<bean id="user" class="entity.User">
<property name="username">
<value>张三</value>
</property>
<property name="age">
<value>23</value>
</property>
</bean>
如果属性值中包含了XML文件的特殊字符(& < > " '),则注入需要进行处理,通常可以采用两种办法,使用标记或把特殊字符替换为实体引用.
<bean id="product" class="entity.Product">
<!-- 使用<![CDATA[]]>标记处理XML特 殊字符 -->
<property name="specialCharacter1">
<value><![CDATA[P&G]]></value>
</property>
<!-- 把XML特殊字符替换为实体引用 -->
<property name="specialCharacter2">
<value>P&G</value>
</property>
<bean>
| 符号 | 实体引用 |
|---|---|
| < | & lt; |
| > | & gt; |
| & | & amp; |
| ' | & apos; |
| " | & quot; |
注意:在XML文件中字符"<"和“&”是非法的,其他3个符号是合法的,但是将它们替换为实体引用是个好习惯
引用其他Bean组件
Spring中定义的Bean可以互相引用,从而建立依赖关系,除了使用ref属性,还可以通过子元素实现.
引用其他Bean组件
<bean id="userDao" class="dao.impl.UserDaoImpl"/>
<bean id="userService" class="service.impl.UserServiceImpl">
<property name="dao">
<ref bean="userDao"/>
</property>
</bean>
使用内部Bean
<!-- 定义内部Bean -->
<bean id="userService" class="service.impl.UserServiceImpl">
<property name="dao">
<bean class="dao.impl.UserDaoImpl"/>
</property>
</bean>
这样这个UserDaoImpl类型的Bean就只能被userUservice使用,其他的Bean则无法使用
注入集合类型的属性
对于List或数组类型的属性,可以使用标签注入
<!-- 注入List类型 -->
<property name="list">
<list>
<!-- 定义List中的元素 -->
<value>足球</value>
<value>篮球</value>
</list>
</property>
标签中间可以使用
标签
Map类型的属性,使用
<!-- 注入Map类型 -->
<property name="map">
<map>
<!-- 定义Map中的键值对 -->
<entry>
<key>
<value>football</value>
</key>
<value>足球</value>
</entry>
<entry>
<key>
<value>basketball</value>
</key>
<value>篮球</value>
</entry>
</map>
</property>
注入null和空字符串值
可以使用
<!-- 注入空字符串值 -->
<property name="emptyValue">
<value></value>
</property>
<!-- 注入null值 -->
<property name="nullValue">
<null/>
</property>
其他增强类型
Spring支持多种增强类型,除了我们上一篇文章说的前置增强和后置增强,在这里我们在补充几种常用的增强类型
异常抛出增强
异常抛出增强的特点是在目标方法抛出异常时织入增强处理。使用异常抛出增强,可以为各功能模块提供统一的,可拨插的异常处理方案
/**
* 定义包含增强方法的JavaBean
*/
public class ErrorLogger {
private static final Logger log = Logger.getLogger(ErrorLogger.class);
public void afterThrowing(JoinPoint jp, RuntimeException e) {
log.error(jp.getSignature().getName() + " 方法发生异常：" + e);
}
}
Spring配置文件
<!-- 声明增强方法所在的Bean -->
<bean id="theLogger" class="aop.ErrorLogger"></bean>
<!-- 配置切面 -->
<aop:config>
<!-- 定义切入点 -->
<aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))" />
<!-- 引用包含增强方法的Bean -->
<aop:aspect ref="theLogger">
<!-- 将afterThrowing()方法定义为异常抛出增强并引用pointcut切入点 -->
<!-- 通过throwing属性指定为名为e的参数注入异常实例 -->
<aop:after-throwing method="afterThrowing"
pointcut-ref="pointcut" throwing="e" />
</aop:aspect>
</aop:config>
</beans>
expression指示符我们上一篇文章已经说话大家可以先看一下上一篇文章
使用aop:after-throwing元素可以定义异常抛出增强。如果需要获取抛出的异常,可以为增强方法声明相关类型的参数,并通过aop:after-throwing元素的throwing的属性指定该参数名称,Spring会为其注入从目标方法抛出的异常实例.
最终增强
最终增强的特点是无论抛出异常还是正常退出,该增强都会得到执行,类似于异常处理机制中finally块的作用,一般用于释放资源,使用最终增强,就可以为各功能模块提供统一的,可拨插的处理方案.
/**
* 定义包含增强方法的JavaBean
*/
public class AfterLogger {
private static final Logger log = Logger.getLogger(AfterLogger.class);
public void afterLogger(JoinPoint jp) {
log.info(jp.getSignature().getName() + " 方法结束执行。");
}
}
Spring配置文件
<!-- 声明增强方法所在的Bean -->
<bean id="theLogger" class="aop.AfterLogger"></bean>
<!-- 配置切面 -->
<aop:config>
<!-- 定义切入点 -->
<aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))" />
<!-- 引用包含增强方法的Bean -->
<aop:aspect ref="theLogger">
<!-- 将afterLogger()方法定义为最终增强并引用pointcut切入点 -->
<aop:after method="afterLogger" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
使用aop:after元素即可定义最终增强
环绕增强
环绕增强在目标方法的前后都可以织入增强处理.环绕增强是功能最强大的增强处理,Spring把目标方法的控制权全部交给它,在环绕增强处理中,可以获取或修改目标方法的参数,返回值可以对它进行异常处理,甚至可以决定目标方法是否被执行.
/**
* 定义包含增强方法的JavaBean
*/
public class AroundLogger {
private static final Logger log = Logger.getLogger(AroundLogger.class);
public Object aroundLogger(ProceedingJoinPoint jp) throws Throwable {
log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
+ " 方法。方法入参：" + Arrays.toString(jp.getArgs()));
try {
Object result = jp.proceed();
log.info("调用 " + jp.getTarget() + " 的 "
+ jp.getSignature().getName() + " 方法。方法返回值：" + result);
return result;
} catch (Throwable e) {
log.error(jp.getSignature().getName() + " 方法发生异常：" + e);
throw e;
} finally {
log.info(jp.getSignature().getName() + " 方法结束执行。");
}
}
}
Spring配置文件
<!-- 声明增强方法所在的Bean -->
<bean id="theLogger" class="aop.AroundLogger"></bean>
<!-- 配置切面 -->
<aop:config>
<!-- 定义切入点 -->
<aop:pointcut id="pointcut" expression="execution(* service.UserService.*(..))" />
<!-- 引用包含增强方法的Bean -->
<aop:aspect ref="theLogger">
<!-- 将aroundLogger()方法定义为环绕增强并引用pointcut切入点 -->
<aop:around method="aroundLogger" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
使用aop:around元素可以定义环绕增强,通过为增强方法声明ProceedingJoinPoint类型的参数,可以获得连接点信息,所用方法与JoinPoint相同.ProceedingJoinPoint是JoinPoint的子接口,其不但封装目标方法及其入参数组,还封装了被代理的目标对象,通过它的proceed()方法可以调用其真正的目标方法,从而达到对连接点的完全控制
常用的增强处理类型
| 增强处理类型 | 特 点 |
|---|---|
| Before | 前置增强处理，在目标方法前织入增强处理 |
| AfterReturning | 后置增强处理，在目标方法正常执行（不出现异常）后织入增强处理 |
| AfterThrowing | 异常增强处理，在目标方法抛出异常后织入增强处理 |
| After | 最终增强处理，不论方法是否抛出异常，都会在目标方法最后织入增强处理 |
| Around | 环绕增强处理，在目标方法的前后都可以织入增强处理 |
Spring AOP配置元素
| AOP配置元素 | 描 述 |
|---|---|
| aop:config | AOP配置的顶层元素，大多数的aop:*元素必须包含在aop:config元素内 |
| aop:pointcut | 定义切点 |
| aop:aspect | 定义切点 |
| aop:after | 定义最终增强（不管被通知的方法是否执行成功） |
| aop:after-returning | 定义after-returning增强 |
| aop:after-throwing | 定义after-throwing增强 |
| aop:around | 定义环绕增强 |
| aop:before | 定义前置增强 |
| aop:aspectj-autoproxy | 启动@AspectJ注解驱动的切面 |
使用注解实现IOC的配置
前面我们说过用xml的形式配置IOC,那种方式是比较麻烦的,在Spring2.0以后的版本我们就可以使用注解来配置,进一步减少了配置文件的代码
使用注解定义Bean
/**
* 用户业务类,实现对User功能的业务管理
*/
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired // 默认按类型匹配
@Qualifier("userDao") // 按指定名称匹配
private UserDao dao;
// 使用@Autowired直接为属性注入，可以省略setter方法
/*public void setDao(UserDao dao) {
this.dao = dao;
}*/
public void addNewUser(User user) {
// 调用用户DAO的方法保存用户信息
dao.save(user);
}
}
上面代码我们通过注解定义了一个名为userDao的Bean@Autowired的作用和在xml文件中编写
还有非常重要的一点就是我们要在配置文件中加一行代码,让他支持我们的注解
<!--扫描包中注解标注的类-->
<context:component-scan base-package="service,dao"/>
<!--多个包之前用逗号隔开-->
Spring还提供了其他的注解
@Componet:实现Bean组件的定义
@Repository:用于标注DAO类
@Service:用于标注业务类
@Controller:用于标注控制器类
@Autowired:实现Bean的自动装配
@Qualifier:指定Bean的名称
@Resource:实现Bean的组件装配
大家可以查看Spring的开发手册 进一步了解他们的用法
使用注解定义切面
AspectJ
面向切面的框架，它扩展了Java语言，定义了AOP 语法，能够在编译期提供代码的织入
@AspectJ
AspectJ 5新增的功能，使用JDK 5.0 注解技术和正规的AspectJ切点表达式语言描述切面
Spring通过集成AspectJ实现了以注解的方式定义增强类，大大减少了配置文件中的工作量
利用轻量级的字节码处理框架asm处理@AspectJ中所描述的方法参数名
使用注解定义切面实现日志功能
/**
* 使用注解定义切面
*/
@Aspect
public class UserServiceLogger {
private static final Logger log = Logger.getLogger(UserServiceLogger.class);
@Pointcut("execution(* service.UserService.*(..))")
public void pointcut() {}
@Before("pointcut()")
public void before(JoinPoint jp) {
log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
+ " 方法。方法入参：" + Arrays.toString(jp.getArgs()));
}
@AfterReturning(pointcut = "pointcut()", returning = "returnValue")
public void afterReturning(JoinPoint jp, Object returnValue) {
log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().getName()
+ " 方法。方法返回值：" + returnValue);
}
}
切入点表达式使用@Pointcut注解来表示,而切入点签名则需要一个普通的方法定义来提供,
如上面代码中的pointcut()方法,作为切入点签名的方法必须返回void类型,切入点定义好后,就可以使用pointcut()签名进行引用
定义完切面后,还需要在Spring配置文件中完成织入工作
<context:component-scan base-package="service,dao" />
<bean class="aop.UserServiceLogger"></bean>
<aop:aspectj-autoproxy />
配置文件中首先要导入aop命名空间,只需要在配置文件中添加aop:aspect-autoproxy/元素,
就可以启用对于@AspecJ注解的支持,Spring将自动为匹配的Bean创建代理
为了注册定义好的切面,还要在Spring配置文件中是声明UserServiceLogger的一个示例,如果不需要被其他的Bean引用,可以不指定id属性
使用注解定义其他类型增强
异常抛出增强
/**
* 通过注解实现异常抛出增强
*/
@Aspect
public class ErrorLogger {
private static final Logger log = Logger.getLogger(ErrorLogger.class);
@AfterThrowing(pointcut = "execution(* service.UserService.*(..))", throwing = "e")
public void afterThrowing(JoinPoint jp, RuntimeException e) {
log.error(jp.getSignature().getName() + " 方法发生异常：" + e);
}
}
使用AfterThrowing注解可以定义异常抛出增强,如果需要获取抛出的异常,可以为增强方法声明相关类型的参数,并通过@AfterThrowing注解的throwing属性指定该参数名称,Spring会为其注入从目标方法抛出的异常实例
其他的方法都是大同小异,大家可以自己动手试一试
@Aspect(定义一个切面 )
@Before(前置增强)
@AfterReturning(后置增强)
@Around (环绕增强)
@AfterThrowing(异常抛出增强)
@After(最终增强)
在配置文件中添加aop:aspectj-autoproxy/元素,启用对于@Aspect注解的支持
写的不好还有不懂的地方,大家可以留言一下 我会尽量解决
by安心