多种方式实现依赖注入
构造注入
编写测试类
- 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 文件的特殊字符 (& <> " '), 则注入需要进行处理, 通常可以采用两种办法, 使用<[CDATA[]]> 标记或把特殊字符替换为实体引用.
- <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 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 类型 -->
- <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 指示符我们上一篇文章已经说话大家可以先看一下上一篇文章
使用
最终增强
最终增强的特点是无论抛出异常还是正常退出, 该增强都会得到执行, 类似于异常处理机制中 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>
使用
环绕增强
环绕增强在目标方法的前后都可以织入增强处理. 环绕增强是功能最强大的增强处理, 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>
使用
增强处理类型 | 特 点 |
---|---|
Before | 前置增强处理,在目标方法前织入增强处理 |
AfterReturning | 后置增强处理,在目标方法正常执行(不出现异常)后织入增强处理 |
AfterThrowing | 异常增强处理,在目标方法抛出异常后织入增强处理 |
After | 最终增强处理,不论方法是否抛出异常,都会在目标方法最后织入增强处理 |
Around | 环绕增强处理,在目标方法的前后都可以织入增强处理 |
Spring AOP 配置元素
AOP 配置元素 | 描 述 |
---|---|
aop:config | AOP 配置的顶层元素,大多数的 & lt;aop:*> 元素必须包含在 |
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 的开发手册 http://shouce.jb51.net/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 命名空间, 只需要在配置文件中添加
使用注解定义其他类型增强
异常抛出增强
- /**
- * 通过注解实现异常抛出增强
- */
- @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(最终增强)
在配置文件中添加
写的不好还有不懂的地方, 大家可以留言一下 我会尽量解决
by 安心
来源: https://www.cnblogs.com/anxin0/p/9946835.html