Spring二：Bean管理（注解方式）和 AOP

一：Bean的管理（注解方式）
步骤一:下载Spring的开发包:
官网：http://spring.io/
下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring解压:(Spring目录结构:)

• docs :API和开发规范.
• libs :jar包和源码.
• schema :约束.

步骤二:创建web项目,引入Spring的开发包:
在Spring的注解的AOP中需要引入spring-aop的jar包。
步骤三:引入相关配置文件:

log4j.properties
applicationContext.xml
引入约束:
spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

* 引入约束:(引入context的约束):
<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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

步骤四:编写相关的类:

public interface UserDao {
	
	public void sayHello();
}

public class UserDaoImpl implements UserDao {

	@Override
	public void sayHello() {
		System.out.println("Hello Spring...");
	}

}

步骤五:配置注解扫描（applicationContext.xml）

<!-- Spring的注解开发:组件扫描(类上注解: 可以直接使用属性注入的注解) -->
	<context:component-scan base-package="com.itheima.spring.demo1"/>

步骤六：在相关的类上添加注解:

@Component(value="userDao")
public class UserDaoImpl implements UserDao {

	@Override
	public void sayHello() {
		System.out.println("Hello Spring Annotation...");
	}

}

步骤七：编写测试类:

@Test
	public void demo2() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.sayHello();
	}

Spring的Bean管理的中常用的注解:
@Component:组件.(作用在类上)
Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)

• @Controller :WEB层
• @Service :业务层
• @Repository :持久层

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强
属性注入的注解:(使用注解注入的方式,可以不用提供set方法.)
@Value :用于注入普通类型.
@Autowired :自动装配:

• 默认按类型进行装配.
• 按名称注入:
• @Qualifier:强制使用名称注入.

@Resource相当于:

• @Autowired和@Qualifier一起使用.
  Bean的作用范围的注解:
  @Scope:
• singleton:单例
• prototype:多例

/**
 * 组件注解，标记类
 * <bean id="userService" class="com.itheima.demo1.UserServiceImpl"> == @Component(value="userService")
 * @author Administrator
 */
@Component(value="userService")
// @Scope(value="prototype")
public class UserServiceImpl implements UserService {
	
	// 给name属性注入美美的字符串，setName方法还可以省略不写
	@Value(value="美美")
	private String name;
	/*public void setName(String name) {
		this.name = name;
	}*/
	
	// @Autowired 按类型自动装配
	// @Autowired
	// @Qualifier(value="userDao")		// 按名称注入
	
	// 是Java的注解，Spring框架支持该注解
	@Resource(name="userDao")
	private UserDao userDao;
	
	public void sayHell() {
		System.out.println("hello Spring!!"+name);
		userDao.save();
	}
	
	@PostConstruct
	public void init(){
		System.out.println("初始化...");
	}
	
}

Bean的生命周期的配置:
@PostConstruct :相当于init-method，在Bean初始化时执行。
@PreDestroy :相当于destroy-method，在Bean销毁时执行。
Spring的Bean管理的方式的比较:

二：AOP的概述
什么是AOP

Spring是解决实际开发中的一些问题:

• AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.

AOP的作用：对程序进行增强:不修改源码的情况下.

• AOP可以进行权限校验,日志记录,性能监控,事务控制.

底层实现:
代理机制: 静态代理机制 两种动态代理机制 JDK底层原理

• Spring的AOP的底层用到两种代理机制：
  • JDK的动态代理 :针对实现了接口的类产生代理.
  • Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

Spring中基于AspectJ的AOP开发
AOP的开发中的相关术语:

• Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
• Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
• Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
• Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
• Target(目标对象):代理的目标对象
• Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.
  spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入
• Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
• Aspect(切面): 是切入点和通知（引介）的结合.

Spring使用AspectJ进行AOP的开发：XML的方式（*****）
1.引入相应的jar包

• spring的传统AOP的开发的包
  spring-aop-4.2.4.RELEASE.jar
  com.springsource.org.aopalliance-1.0.0.jar
• aspectJ的开发包:
  com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
  spring-aspects-4.2.4.RELEASE.jar
  
  2.引入Spring的配置文件
  引入AOP约束(在applicationContext.xml中添加):

<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>

1.2.7.3编写目标类
创建接口和类:

public interface OrderDao {
	public void save();
	public void update();
	public void delete();
	public void find();
}

public class OrderDaoImpl implements OrderDao {

	@Override
	public void save() {
		System.out.println("保存订单...");
	}

	@Override
	public void update() {
		System.out.println("修改订单...");
	}

	@Override
	public void delete() {
		System.out.println("删除订单...");
	}

	@Override
	public void find() {
		System.out.println("查询订单...");
	}

}

1.2.7.4目标类（所要进行增强的类）的配置

1.2.7.5整合Junit单元测试
引入spring-test.jar

@RunWith(SpringJUnit4ClassRunner.class)//让测试运行在Spring测试环境
@ContextConfiguration("classpath:applicationContext.xml")//加载配置文件
public class SpringDemo3 {
	@Resource(name="orderDao")
	private OrderDao orderDao;
	
	@Test
	public void demo1(){
		orderDao.save();
		orderDao.update();
		orderDao.delete();
		orderDao.find();
	}
}

通知类型
前置通知 ：在目标方法执行之前执行.
后置通知 ：在目标方法执行之后执行
环绕通知 ：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现 异常的时候 执行
最终通知 ：无论目标方法是否出现异常 最终通知都会 执行.

切入点表达式

execution(表达式)
表达式:
[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数)
public * cn.itcast.spring.dao.*.*(..)
* cn.itcast.spring.dao.*.*(..)
* cn.itcast.spring.dao.UserDao+.*(..)
* cn.itcast.spring.dao..*.*(..)

编写一个切面类

public class MyAspectXml {
	// 前置增强
	public void before(){
		System.out.println("前置增强===========");
	}
}

1.2.7.9配置完成增强

<!-- 配置切面类 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>

<!-- 进行aop的配置 -->
<aop:config>
	<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.OrderDao.save(..))" id="pointcut1"/>
	<!-- 配置切面 -->
	<aop:aspect ref="myAspectXml">
		<aop:before method="before" pointcut-ref="pointcut1"/>
	</aop:aspect>
</aop:config>

其他的增强的配置：

<!-- 配置切面类 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>

<!-- 进行aop的配置 -->
<aop:config>
	<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.save(..))" id="pointcut1"/>
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.delete(..))" id="pointcut2"/>
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.update(..))" id="pointcut3"/>
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.find(..))" id="pointcut4"/>
	<!-- 配置切面 -->
	<aop:aspect ref="myAspectXml">
		<aop:before method="before" pointcut-ref="pointcut1"/>
		<aop:after-returning method="afterReturing" pointcut-ref="pointcut2"/>
		<aop:around method="around" pointcut-ref="pointcut3"/>
		<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
		<aop:after method="after" pointcut-ref="pointcut4"/>
	</aop:aspect>
</aop:config>