Spring4_Day02

Spring4_Day01

Spring的IOC注解开发（重点）

入门案例

1. 创建一个web项目
2. 引入相应的包

3. 创建applicationContext.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">
</beans>

4. 编写相关的类

package com.lld.Dao.Impl;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import com.lld.Dao.UserDao;

@Component("UserDao")//这一句话相当于<bean id="UserDao" class="com.lld.Dao.Impl.UserDaoImpl" />
public class UserDaoImpl implements UserDao {

	@Value("曲光光")//类似于将值注入到name中
	private String name;
	
	@Override
	public void save() {
		System.out.println("UserDao执行成功......"+name);
	}

}

5. 在applicationContext.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="com.lld"/><!-- 该段说明com.lld包下面的都使用注解的方法执行 -->	
</beans>

6. 编写测试类

@Test
	/*
	 * 注解方式
	 */
	public void demo02(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		UserDao userDao = (UserDao) applicationContext.getBean("UserDao");
		
		userDao.save();
	}

7. 运行结果
   

Spring的IOC注解详解

@Component：组件（作用在类上）

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

属性注入的注解：（使用注解注入的方式，可以不提供set方法）

• @Value（） ：用于注入普通类型
• @Autowired（）：自动装配

1.默认按照类型进行匹配
2.按照名称注入
@Qualifier ：强制使用名称注入

• @Resource(name=" ")相当于

@Autowired和@Qualifier(" ")一起使用

生命周期注入

• @PostConstruct ：创建时调用
• @PreDestroy ：销毁时调用

作用范围注解

• @scope("")

    1. singleton				：单例
    2. prototype				：多例
    3. request				：创建后存入request域中
    4. session				：创建后存入session域中
    5. globalsession			：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session。
  

IOC的XML和注解开发比较

XML和注解的比较

• 适用场景

xml：任何场景（结构清晰，方便维护）
注解：有些地方用不了，在这个类不是自己编写的时候，注解无法往源代码上加（开发方便）

XML和注解整合开发

• XML管理Bean，注解完成属性注入
• 在使用注解和xml整合开发时将<context:component-scan base-package=“com.lld”/>换成<context:annotation-config />

<!-- <context:component-scan base-package="com.lld"/>该段说明com.lld包下面的都使用注解的方法执行 -->
		<context:annotation-config /><!--在只使用注解进行属性注入时，使用该标签-->

AOP概述（面向切面编程）

什么是AOP

为什么学习AOP

对程序进行增强：在不修改源码的情况下

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

SpringAOP的由来

AOP 最早由 AOP 联盟的组织提出的,制定了一套规范.Spring 将 AOP 思想引入到框架中,必须遵守 AOP 联盟的规范

底层实现

代理机制:

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

Spring的基于Aspectj的开发

AOP开发中的相关术语及解释

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

入门练习

1. 创建web项目引入jar包

2.编写目标类（被增强的类）

• 接口

package demo2;

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

• 实现类

package demo2;

public class ProductDaoImpl implements ProductDao {

	@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("寻找商品...");
	}

}

3.编写增强类

package demo2;

public class MyAspectXml {
	
	public void before(){
		System.out.println("进行权限校验...............");
	}
}

4.添加配置文件（applicationContext.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" 
    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"> <!-- bean definitions here -->

	<!-- 把目标类交给spring管理 -->
	<bean id="ProductDao" class="demo2.ProductDaoImpl" />
	
	<!-- 将切面类交给spring管理 -->
	<bean id="MyAspectXml" class="demo2.MyAspectXml" />
	
	<!-- 进行AOP配置 -->
	<aop:config>
	
		<!-- 配置被增强的方法 -->
		<aop:pointcut expression="execution(* demo2.ProductDao.save(..))" id="pointcut1"/>
		
		<!-- 
			1. 配置增强的方法
				* ref:增强的类的id
		 -->
		<aop:aspect ref="MyAspectXml">
			<!-- 
				* method:使用增强类的那一个方法增强 
				* pointcut-ref:被增强的方法
			-->
			<aop:before method="before" pointcut-ref="pointcut1"/>
		</aop:aspect>
	
	</aop:config>

</beans>

5.整合Junite测试

• 导入jar包

spring-test-4.2.4.RELEASE.jar

• 添加注解

@RunWith(SpringJUnit4ClassRunner.class) #固定格式
@ContextConfiguration(“classpath:applicationContext.xml”) #classpath后面写要读取得配置文件

• 测试代码

package demo2;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)						//固定格式
@ContextConfiguration("classpath:applicationContext.xml")	//classpath后填写要读取得配置文件
public class demo2 {
	@Resource(name="ProductDao")							//使用属性注入
	private ProductDao ProductDao;
	@Test
	public void demo01(){
		ProductDao.save();
		ProductDao.delete();
		ProductDao.find();
		ProductDao.update();
		
	}
}

Spring通知解释

1. 前置通知：在目标方法执行前进行操作

• 前置通知：获得切入点信息

2. 后置通知：在目标方法执行后操作

• 后置通知：获得方法值

3. 环绕通知：在目标方法执行前和执行后操作

• 环绕通知：

4. 异常抛出通知：在程序出现异常时进行操作

5. 最终通知：无论代码是否有异常，总是会执行

6. 引介通知（不会用）

• 增强类代码

package demo2;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspectXml {
	
	/**
	 * 前置通知
	 * @param joinPoint
	 */
	public void before(JoinPoint joinPoint){
		System.out.println("进行权限校验..............."+joinPoint);
	}
	
	/**
	 * 后置通知
	 * @param result
	 */
	public void writeLog(Object result){
		System.out.println("进行日志记录................."+result);
	}
	
	/**
	 * 环绕通知
	 * @param joinPoint
	 * @return
	 * @throws Throwable
	 */
	public Object around(ProceedingJoinPoint joinPoint)throws Throwable{
		
		System.out.println("环绕前通知......");
		Object object = joinPoint.proceed();
		System.out.println("环绕后通知......");
		
		return object;
	}
	
	/**
	 * 异常通知
	 * @param ex
	 */
	public void afterThrowing(Throwable ex){
		System.out.println("异常抛出通知"+ex.getMessage());
	}
	
	public void after(){
		System.out.println("最终通知");
	}
}

• 被增强类代码

package demo2;

public class ProductDaoImpl implements ProductDao {

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

	@Override
	public void update() {
		System.out.println("商品更新...");
	}

	@Override
	public String delete() {
		System.out.println("商品删除...");
		return "曲秃";
	}

	@Override
	public void find() {
		System.out.println("寻找商品...");
	}

}

• 配置文件

<?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"> <!-- bean definitions here -->

	<!-- 把目标类交给spring管理 -->
	<bean id="ProductDao" class="demo2.ProductDaoImpl" />
	
	<!-- 将切面类交给spring管理 -->
	<bean id="MyAspectXml" class="demo2.MyAspectXml" />
	
	<!-- 进行AOP配置 -->
	<aop:config>
	
		<!-- 配置被增强的方法 -->
		<aop:pointcut expression="execution(* demo2.ProductDao.save(..))" id="pointcut1"/>
		<aop:pointcut expression="execution(* demo2.ProductDao.delete(..))" id="pointcut2"/>
		<aop:pointcut expression="execution(* demo2.ProductDao.update(..))" id="pointcut3"/>
		<aop:pointcut expression="execution(* demo2.ProductDao.find(..))" id="pointcut4"/>
		
		<!-- 
			1. 配置增强的方法
				* ref:增强的类的id
		 -->
		<aop:aspect ref="MyAspectXml">
			<!-- 
				* aop:before:前置通知
				* method:使用增强类的那一个方法增强 
				* pointcut-ref:被增强的方法
			-->
			<aop:before method="before" pointcut-ref="pointcut1"/>
			<!-- aop:after-returning:后置通知 -->
			<aop:after-returning method="writeLog" pointcut-ref="pointcut2" returning="result"/>
			<!-- aop:around:环绕通知 -->
			<aop:around method="around" pointcut-ref="pointcut3"/>
			<!-- aop:after-throwing:异常抛出通知 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"/>
			<!-- aop:after -->
			<aop:after method="after" pointcut-ref="pointcut4"/>
			
		</aop:aspect>
	
	</aop:config>

</beans>

切面表达式

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