注解IOC

.Spring的IOC注解开发

一.Spring的ioc的注解开发

1.创建，引入相应的jar包
引入的jar包（Spring4）
spring4需要引入aop包，之前的包不需要

2.引入核心配置文件
在src下创建applicationContext.xml配置文件
约束：
使用注解开发需要引入context约束

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

</beans>

3.创建一个接口和实现类
3.1开启IOC注解扫描

<!--使用 Spring Ioc 的注解方式，在applicationcontext.xml中
	配置一个组件扫描,（哪个包下面的类使用IOC注解）
 -->
<context:component-scanf base-package="com.Demo1"/>

3.2实现类，在类上添加注解

/**
 * 用户Dao的实现类
 * 来添加注解

 * @author 86139

 */
/*
@Component(value = "UserDao")相当于在xml中配置的   value :可要可不要
<bean id = "UserDao" class="com.Demo1.UserDaoImpl"/>

在没有set方法时，就将属性值直接赋值到属性之上：@Value("张三")
在有set方法时，就将属性值直接赋值到set构造方法之上：@Value("张三")
*/

@Component(value = "UserDao")
public class UserDaoImpl implements UserDao{
	@Value( "张三")
	private String name;
	@Override
	public void save() {
		System.out.println("DAO保存用户执行" +"..." + name);		
	}

}

调用Spring

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

二：IOC的注解详解

1：@Component:组件
*1.1修饰一个类，将这个类交给Spring管理
*1.2这个注解衍生了三个注解（功能相似）：来修饰类分别对应每一层
**1.2.1：@ Controller：web层
**1.2.2：@Service：service层
**1.2.3：@Repository： dao层
2.属性注入的注解
*2.1.普通属性：
**@Value：普通属性的值
*2.2对象属性设置：
**@Autowired:设置对象类型的属性的值，但是按照类型完成属性的注入，
习惯按照名称完成属性的注入，所以是@Autowired+@Qualifier(“xxx”)来进行组合使用
**但是还有其他注解来替代这两个注解，@Resource
3.Bean的其他的注解
Bean的作用范围
1：@Scope:作用范围
1.1：singleton：单利
1.2：prototype：多例

xml配置和ioc混合使用

<!-- 在没有扫描的情况下，使用属性注解  @Resource、@Value、@Autowired...-->
<context:annotation-config>
<bean id = "productdao" class = "xxxxxx"></bean>

xml配置

public class OrderDao {
	public void save() {
		System.out.println("OrderDao的方法执行");
	}
}



public class ProductDao {
	public void save() {
		System.out.println("ProductDao的方法执行");
	}
}




public class ProductService {
@Resource(name = "productDao") //添加了Resource注释则不需要set方法
	private OrderDao orderDao;
	private ProductDao productDao;
	public void setOrderDao(OrderDao orderDao) {
		this.orderDao = orderDao;
	}
	public void setProductDao(ProductDao productDao) {
		this.productDao = productDao;
	}
	public void save() {
		System.out.println("ProductService的方法执行");
		productDao.save();
		orderDao.save();
	}
}



public class SpringDemo44 {
	@Test
	public void demo1() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		ProductService productService = (ProductService) applicationContext.getBean("productService");
		productService.save();
	}
}




<!-- 开启IOC注解扫描 -->
 	<context:component-scan base-package="com.Demo1,com.Demo2" />
 	
 	<bean id = "productService"  class="demo3.ProductService">
 		<property name="orderDao" ref="orderDao"></property>
 		<property name="ProductDao" ref="productDao"></property>
 	</bean>
 	
 	<bean id="orderDao" class="demo3.OrderDao" ></bean>
 	<bean id="productDao" class="demo3.ProductDao" ></bean>

AOP的xml配置

1.
AOP就是面向切面编程。AOP是OOP的扩展和延伸，解决OOP开发遇到的问题
2.
Sping底层的AOP实现的原理就是动态代理
jdk动态代理和cglib的动态代理
3.
Spring的AOP开发

*AOP思想最早是由AOP联盟组织提出的。Spring使用的这种思想
** Spring的AOP有自己实现的组织方式
** AsprectJ是一个AOP的框架，Spring引入

*Spring基于Aspectj的AOP的开发使用
4.
Spring底层的AOP实现原理
动态代理
*JDK动态代理：实现了接口的类产生的代理
* Cglib 动态代理：对没有实现的接口产生的代理对象
*
5.AOP的开发的相关术语
一、Joinpoint(连接点):
所谓连接点是指那些被拦截到的点。在 spring 中,这些所谓的点指就是方法,因为 spring 只支持方法类型的连接点。

二、Pointcut(切入点)：
所谓切入点是指需要进行增强的连接点（Joinpoint）

三、Advice( 通知/ 增强：）
所谓通知是指拦截到 Joinpoint 之后，需要加入增强的部分，比如（rú）[事物、日志]
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知【是指人为使用代码的形式去指定通知的运行顺序，而不是依靠spring默认指定】。

四、Target(目标对象):
所谓通知是指被代理的对象

五、Aspect(切面):
Pointcut(切入点) + 通知

连接点：类里面那些有可能被增强方法

切入点：在类面实实在在被增强的方法

通知：增强的逻辑，称为增强。比如扩展的日志功能、事务

切面：把增强应用到具体方法上面，过程称之为切面，把增强用到切入点过程

5.AOP的开发

创建web项目

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


package com.Demo01;

public class ProductImpl implements ProductDao{

	@Override
	public void save() {
		// TODO Auto-generated method stub
		System.out.println("保存商品");
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("修改商品");
	}

	@Override
	public void find() {
		// TODO Auto-generated method stub
		System.out.println("查找商品");
	}

	@Override
	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("删除商品");
	}

}

测试类

package com.Demo01;

import javax.annotation.Resource;

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

/**
 * 调用
 * @author 86139
 *使用下面的jdk进行配置就可以让spring帮你完成测试
 */

//固定搭配
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo01 {
	//name：xml文件中的实现类名
	@Resource(name="productDao")
	private ProductDao productDao;
	
	@Test
	public void demo01() {
		productDao.save();
		productDao.update();
		productDao.find();
		productDao.delete();
	}
}

xml：

```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 -->
        
        <!-- 配置增强类 -->
    <bean id = "productDao" class="com.Demo01.ProductImpl"></bean> 
    
    <!-- 配置切面类 -->
    <bean id = "myAspectXML" class = "com.Demo01.MyAspectXML"></bean>
    
    <!-- 使用aop配置完成对目标类产生代理 -->
    <aop:config>
    	<!-- 定一个切入点 
    	表达式配置哪些类的哪些方法需要进行增强 
    	-->
    <aop:pointcut expression="execution(* com.Demo01.ProductImpl.save(..))" id="pointcut1"/>
    <!-- 配置切面   ref 是切面id-->
    	<aop:aspect ref="myAspectXML">
    		<!-- method:为切面类名  pointcut-ref：为增强类的id （上面配置的id）  before  在增强类之前-->
    		<aop:before method="checkPri" pointcut-ref="pointcut1"/>
    	</aop:aspect>
    </aop:config>
    
</beans>

aop配置有6种通知类型
前置通知
后置通知
配置：

<!-- 前置通知-->
  <aop:pointcut expression="execution(* com.Demo01.ProductImpl.save(..))" id="pointcut1"/>
    <!-- 后置通知 -->
    <aop:pointcut expression="execution(* com.Demo01.ProductImpl.delete(..))" id="pointcut2"/>
    <!-- 配置切面   ref 是切面id-->
    	<aop:aspect ref="myAspectXML">
    	<!-- 前置通知 -->
    		<!-- method:为切面类名  pointcut-ref：为增强类的id （上面配置的id）  before  在增强类之前-->
    		<aop:before method="checkPri" pointcut-ref="pointcut1"/>
    		
    		<!--  后置通知 -->
    		<!-- returning 是收取实现类的增强类的返回值  名称可以随便区名称 -->
    		<aop:after-returning method="WriteLog" pointcut-ref="pointcut2" returning="result"/>
    	</aop:aspect>

返回值

//实现类
@Override
	public String delete() {
		// TODO Auto-generated method stub
		System.out.println("删除商品");
		return "后置通知";
	}






public void WriteLog(Object result) {
		System.out.println("==========日志记录========" +result);
	}

环绕通知

<!--  环绕通知 -->

<aop:pointcut expression="execution(* com.Demo01.ProductImpl.update(..))" id="pointcut3"/>
    		<aop:around method="around" pointcut-ref="pointcut3"/>

public void around(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("==========环绕前通知========");
		//执行目标程序
		Object object = joinPoint.proceed();
		System.out.println("==========环绕后通知========");
	}

aop切入点表达式
基于execution的函数
语法：
[访问修饰符] 方法返回值 包名.类名.方法名(参数)