Spring框架使用(控制反转,依赖注入,面向切面AOP)

参见：http://blog.csdn.net/fei641327936/article/details/52015121

Mybatis：

实现IOC的轻量级的一个Bean的容器

Inversion of control 控制反转：由容器控制程序之间的关系，不是程序代码操作

Depend Inject 依赖注入

Aspect oriented programming 面向切面编程

Spring能帮助我们根据配置文件创建及组装对象之间的依赖关系；

Spring面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制

Spring能非常简单的帮我们管理数据库事务

谁依赖谁：应用程序依赖于IOC容器

为什么需要依赖：应用程序需要IOC容器来提供对象需要的外部资源

谁注入谁：IOC容器注入应用程序某个对象，应用程序依赖的对象

注入了什么：注入某个对象所需要的外部资源(包括对象，资源，常量数据)

Bean:由IOC容器管理的那些组成你应用程序的对象我们叫Bean

控制反转：就是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权利转移到第三方。

控制的什么被反转了：获得依赖对象的方式反转了

缺点：

1>.IOC容器生成对象是通过反射方式，在运行效率上有一定的损耗。如果追求运行效率的话，就必须对此进行权衡。

2>.需要进行大量的配置工作，比较繁琐，对小项目而言，加大一些工作成本。

1.依赖注入的方式：

第一种方法：依赖get() set()方法实例化Bean

1>.如果默认注册为default-autowire="byname"，则bean里面的参数就不用写了

2>.如果不写默认注册为名称，则bean里面需要property(name和ref)

第二种方式：依赖构造方法实例化Bean

1>.如果默认注册为default-autowire="constructor"则bean里面的constructor-arg就不用写了。

2>.如果不写默认注册为构造，则bean里面需要写constructory-arg ref

第三种方式：注解

只写属性，属性上面@Resource(type=类.class)

配置文件需要配置自动扫描

<context:component-scan base-package="包名前面"></...>

1.  <context:annotation-config/>
       <!-- （当前实例在spring容器中的标识 class 当前类的包名和类名） -->
       <bean id="bookDao" class="com.hellojava.dao.BookDao"></bean>
    <bean id="oracleBookDao" class="com.hellojava.dao.OracleBookDao"></bean>  
   
    <bean id="bookService" class="com.hellojava.business.BookService"></bean>
        <!-- 使用get() set()方法   实例化bean(默认注册为 default-autowire="byName"这里就可以不用写)
        <property name="bookDao" ref="bookDao"></property>  
   
        使用构造器方法    实例化bean(默认注册为 default-autowire="constructor"这里就可以不用写)
        <constructor-arg  ref="bookDao"></constructor-arg>
    </bean> -->
    <context:component-scan base-package="com.hellojava"></context:component-scan>  

1>.通过注解注入Bean

@Autowired:自动装配

根据类型注入，用于构造器，字段，方法注入

*写在哪个上面，相当去在xml文件中写的default-autowire

2>.通过JSR-250注解

@Resource:自动装配

只用于setter(方法注入)  配置@Resource(type=类名)或者(name=属性)

3>.@Service注解一个业务类

@Resource:自动装配

@Repository:持久层的注解

2.Spring AOP 面向切面编程

通知Advice：定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。

连接点Joinpoint：程序能够应用通知的一个"时机"，这些"时机"就是连接点，类如方法被调用时，异常被抛出时等。

切入点Pointcut：通知定义了切面要发生的"故事"和时间，那么切入点就是定义了"故事"发生的地点，类如某个类或者方法的名称。

切面Aspect：通知和切入点共同组成了切面(时间，地点和要发生的"故事")

引入Introduction：引入我们向现有的类添加新的方法和属性(spring提供了一个方法注入的功能)

目标Target：即被通知的对象

代理Proxy：应用通知的对象，原生对象(基础)+切面(JDK动态代理或者CGLIB代理(hibernate))

织入Weaving：把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机

1>.编译时：当一个类文件被编译时进行织入

2>.类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码

3>.运行时：切面在运行的某个时刻被织入，springAOP就是以这种方式织入切面的，原理使用了JDK的动态代理技术。

Spring提供了4种实现AOP的方式：

1>.经典的基于代理的AOP

2>.@AspectJ注解驱动的切面

3>.纯POJO切面

4>.注入式AspectJ切面

基于代理的AOP:

1>.创建通知：实现这几个接口，把其中的方法实现了

Before 前  After-returning 返回后  After-throwing 抛出后  Arround 周围/环绕  Introduction 引入

2>.定义切点和通知者：在Spring 配置文件中配置这些信息

3>.使用proxyFactoryBean来生成代理

在配置文件里面：

1>.写被代理对象的Bean

2>.定义切面和通知(Before After-returning After-throwing Interceptor)

3>.使用proxyBean 把通知代理到原生对象上

@AspectJ注解驱动的切面

1>.配置文件自动扫描 comntext:component-scan

2>.配置文件aop:aspectj-autoproxy

3>.持久层@component("")

4>.切面 @Aspect @Component @通知(Before... ...)

AOP标签配置+注解

1>.持久层@Component("")

2>.切面@Component("")

3>.配置文件：

定义：切入点pointcut

切面：Aspect

通知：Advice 方法为方法名  ref为切入点

 //@Service("bookService")
 public class BookService {
 //第三种方法：@Resource(type=IBaseDao.class)写在属性上面  ，配置文件需要配置自动扫描
     //@Resource(type=IBaseDao.class)
     @Resource(name="bookDao")
     private IBaseDao bookDao;
 //  第一种方法：依赖get() set()方法  实例化bean
     public IBaseDao getBookDao() {
         return bookDao;
     }
     public void setBookDao(IBaseDao bookDao) {
         this.bookDao = bookDao;
     }
 //  第二种方法：依赖构造方法 实例化bean
     /*public BookService(){}
     public BookService(IBaseDao bookDao){
         this.bookDao=bookDao;
     }*/  

     public void hello(){
         String h=bookDao.hello();
         System.out.println(h);
     }
 }