spring2.5

1：IOC:控制反转，不再把依赖对象交给应用本身创建和维护，而是交给外部容器创建和维护。这样控制权由应用转移到外部容器。
2：DI:依赖注入，在运行期，由外部容器动态的将依赖对象注入到组件中，可以通过构造函数的参数形式注入，也可以通过set方法注入。

3：为何要使用Spring
a.降低组件之间的耦合度，实现软件各层之间的解耦
Controller---Service---Dao
b.可以使用容器提供的各种服务，不需要处理复杂的事物传播行为
事务管理
c.容器提供单例模式，开发人员不需要自己编写实现代码
d.容器提供AOP技术，利用它很容易实现如权限拦截，运行期监控等功能。
e.容器提供了众多的辅佐类，使用这些类能够加快应用的开发，
如：jdbcTemplate、HibernateTemplate.
d.Spring对于主流的应用框架提供了集成支持，
如：集成hibernate、JPA、Structs 等，这样更便于应用的开发

4：轻量级与重量级概念的划分
主要看它使用了多少服务

如何使用spring？
使用spring需要的jar包
添加配置文件beans.xml,加入<bean id = "" class = "需要注入的类的路径"></bean>
ApplicationContext ctx =
new ClassPathXmlApplicationContext(String []{"beans.xml"})
ctx.getBean("配置文件中需注入类的class属性")
这样就可以得到我们所依赖的对象了，这个依赖对象由spring帮我们管理

Spring是如何读取beans.xml的？

Bean的作用域
scope=""
1.singleton 默认
容器实例化时对象被实例化，只创建一个对象
2.pototype
调用getBean()方法时被实例化，每次都会创建一个新对象

我们可以延迟实例化
在<bean>中加上 lazy-init = "true"
如果我们要将所有的bean都延迟实例化 就在<beans>中加入
default-lazy-init = "true"
如果需要当<bean>被实例化时就执行方法 就在<bean>中加入init-method = "方法名"
看一个对象是否被实例化，在他的默认构造方法中输出一句话 看看构造方法是否被调用

当我们需要关闭容器时执行某个方法，在bean中加入 destroy-method="方法名"

使用setter方法进行注入：
要将service层和dao层彻底解耦，我们需要将dao实现类所实现的接口直接注入到service
层，然后提供set、get方法，直接可以用注入的接口调用方法，在beans.xml中注入接口
的实现类，然后将它注入到service层的bean中作为属性，
<property name="personDao1" ref="personDao1" ></property>
name="属性名"

事实上是：先将PersonDaoBean注入到spring容器中，然后再将注入到spring容器中的
PersonDaoBean作为属性注入到PersonServiceBean中作为属性，命名为personDao，事实
上personDao本来就是PersonServiceBean的属性，所以啊，通过这么一来 就把
PersonDaoBean注入到PersonServiceBean中了 ，那么这时候PersonServiceBean
通过personDao就可以调用PersonDaoBean中的方法了。如此而已。 注意哦：这样注入就不要再提供带参构造方法了！！！

例子：

  <bean id = "studentDao" class = "Student.Dao.Impl.StudentDaoImpl"></bean>
 <bean id = "studentServiceBean" class = "Student.Service.StudentServiceBean">
 <property name="studentDao" ref="studentDao"></property>
 </bean>

还可以使用内部Bean方式为属性注入值，但不能被其他调用
像这样：

 <property name="studentDao">
 <bean class="Student.Dao.Impl.StudentDaoImpl"/>
 </property>

注入基本类型：<property name="属性名" value="属性值"/> 定义一个变量，
然后生成get、set方法，

注入集合：

 <property name="set">
 <set>
 <value>一</value>
 <value>二</value>
 <value>三</value>
 </set>
 </property>
 <property name="list">
 <list>
 <value>一list</value>
 <value>二list</value>
 <value>三list</value>
 </list>
 </property>
 <property name="map">
 <map>
 <entry key="key1" value="v1"></entry>
 <entry key="key2" value="v2"></entry>
 <entry key="key3" value="v3"></entry>
 </map>
 </property>
 <property name="map1">
 <map>
 <entry key="key-map1" value="value-map1"></entry>
 <entry key="key-map2" value="value-map2"></entry>
 <entry key="key-map3" value="value-map3"></entry>
 </map>
 </property>

通过构造器注入值

 <constructor-arg index="0" ref="personDao1"></constructor-arg>
 <constructor-arg index="1" value = "sss"></constructor-arg>    

index表示构造器参数的索引，从0开始

使用注解的方式注入依赖对象
@Autowired或者@Resource注解进行装配。但我们需要在xml配置文件中配置一下信息。
@Autowired：默认按类型进行装配
@Resource：默认按名称进行装配，名称找不到再按类型装配
@Resource
private PersonDao personDao1;
根据字段名称，到beans.xml中寻找名称相同的bean，然后将这个bean注入进来
如果找不到就会根据类型去找
不一定要注入在字段上，还可以注入到set方法上

当一个项目需要注入多个bean时，配置文件就会变的臃肿，因此在spring2.5的时候为我们提供
了<context:component-scan base-package="cn.itcast"></context:component-scan>
去自动扫描包下面的标注了注解@Service和@Repository和@component和@Controller
的类，并将这些类自动纳入spring容器中管理。同时可以为这些类指定作用域和名字哦，如：@Resource("name1") @Scope("pototype"),如果没有指定名称的话，这时候ctx.getBean("bean名称")中的bean名称就是类名称，但首字母小写

被@PostConstructs注解的方法是在Bean初始化时被调用的方法
被@PreDestory注解的方法是Bean实例被销毁之前调用该方法

AOP--切面
proxy代理类，只有是面向接口编程时 才能使用proxy代理类
目标对象必须要实现接口
代理对象实现了目标对象的所有方法，

使用cglib创建代理对象

springAOP

定义一个切面(基于注解)：

 /**
  * 切面
  *
  */
 @Aspect
 public class MyInterceptor {
     @Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean.*(..))")
     private void anyMethod() {}//声明一个切入点

     @Before("anyMethod() && args(name)")
     public void doAccessCheck(String name) {
         System.out.println("前置通知:"+ name);
     }
     @AfterReturning(pointcut="anyMethod()",returning="result")
     public void doAfterReturning(String result) {
         System.out.println("后置通知:"+ result);
     }
     @After("anyMethod()")
     public void doAfter() {
         System.out.println("最终通知");
     }
     @AfterThrowing(pointcut="anyMethod()",throwing="e")
     public void doAfterThrowing(Exception e) {
         System.out.println("例外通知:"+ e);
     }

     @Around("anyMethod()")
     public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
         //if(){//判断用户是否在权限
         System.out.println("进入方法");
         Object result = pjp.proceed();
         System.out.println("退出方法");
         //}
         return result;
     }

 }

定义一个切面（基于配置文件）：

 <?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"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
         <aop:aspectj-autoproxy/>
         <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean"></bean>
         <bean id="aspetbean" class="cn.itcast.service.MyInterceptor"/>
         <aop:config>
             <aop:aspect id="asp" ref="aspetbean">
                 <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>
                 <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
                 <aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
                   <aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing"/>
                   <aop:after pointcut-ref="mycut" method="doAfter"/>
                   <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
             </aop:aspect>
         </aop:config>
 </beans>

spring aop execution表达式说明

 在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点"

 例如定义切入点表达式 execution(* com.sample.service.impl..*.*(..))

 execution()是最常用的切点函数，其语法如下所示：

  整个表达式可以分为五个部分：

  1、execution(): 表达式主体。

  2、第一个*号：表示返回类型，*号表示所有的类型。

  3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

  4、第二个*号：表示类名，*号表示所有的类。

  5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。