Spring笔记（二）

一、使用注解配置Spring

 步骤：1.为主配置文件引入新的约束

<beans>
    <!--指定扫描cn.itcast.bean下的所有类中的注解-->
  <context:component-scan
         base-package="cn.itcast.bean"></context:component-scan>
     3.在类中使用注解

  @Component("user")
//相当于在xml文件中<bean name="user" class="cn.itcast.bean.User"/>

    @Service（"user") 表示Service层的
    @Controller（"user")表示Controller控制层的
    @Repository("user")表示dao层的

二、Spring中的STS插件安装
   三种安装方式
  1.手动安装插件（成功率低）
  2.使用老师的Eclipse
  3.使用Spring装好插件的Eclipse

如果安装成功，右击applicationContext-->open with-->Spring config



三、Spring与JUnit整合测试
 1.


四、Spring中的AOP思想
1.横向重复，纵向抽取
 
        Servlet解决乱码          Servlet解决乱码        Servlet解决乱码
                                
                             Filter解决乱码


   Servlet解决乱码      Servlet解决乱码            Servlet解决乱码
      管理事务               管理事务                   管理事务     

                           InvocationHandler管理事务



2.Spring中的AOP概念
  Spring能够为容器中管理的对象生成动态代理对象，以前我们要使用动态代理，我们需要自己调用这个方法生成代理对象
  Spring能帮我们生成代理对象
                     
配置注解扫描
<!--spring的注解开发：组件扫描（类上注解，可以直接使用属性注入的注解-->
<context:component-scan base-package="com.itheima.spring.demo1"/>
在相关类上添加注解
@Component (value="userDao")
相关类的编写
…………

准备工作：导入aop包（约束） 命名空间
1.配置目标对象
<bean name="userServiceTarget" class="cn.itcast.service.UserServiceImpl">
2.配置通知对象
<bean name="myAdvice" class=""></bean>
3.配置将他通知织入目标对象
<aop:config>
  配置切入点
public void cn.itcast.service.UserServiceImpl.save()
  void cn.itcast.service.UserService.UserServiceImpl.save()
* cn.itcast.service.UserServiceImpl.save()
*cn.itcast.service.UserServiceImpl.*()
*cn.itcast.service.UserServiceImpl.*()

*cn.itcast.service.ServiceImpl.*(..)


AOP的梳理
1.AOP思想：AOP是面向切面编程
 横向重复，纵向抽取（如，过滤器，动态代理）
动态代理：1.通过动态代理可以体现aop思想
          2.对象目标对象中的方法进行增强
Spring 能够为容器中管理的对象生成动态代理对象

以前要使用动态代理，我们需要自己调用下面这个方法
Proxy.newProxyInstance(xx,xx,xx）来生成代理对象

实现AOP的原理
1.动态代理优先：被代理的对象必须实现接口，才能产生代理对象，如果没有接口将不能使用 动态代理技术
2.cglib代理（没有接口）：cglib代理可以对任何类生成代理，代理的原理是对目标对象进行继承代理，如果目标对象被final修饰，那么该类无法 被cglib代理

AOP的相关 名词解释
 1.Joinpoint（连接点）目标对象中，所有可以 增强的方法
 2.Pointcut（切入点）：目标对象中，已经增强的方法
 3.Advice（通知/增强）：增强的代码
 4.Target（目标对象）：被代理的对象
 5.Weaving（织入）：将通知应用到切入点过程
 6.Proxy（代理）：将通知织入到目标对象之后，形成代理对象
 7.Aspect（切面）：切入点 *通知

Spring中AOP的步骤演示
1.导包4+2
  Spring中的AOP包：spring-aspect-4.2.4.RELEASE.jar和
                  spring.aop-4.2.4.RELEASE.jar
  Spring需要 第三方 AOP包：  com.springsource.org.aopallliance-1.0.0.jar
                   com.springsource.org.aspectj.weaver1.6.8.RELEASE.jar
2.准备目标对象：就是要代理的目标对象
  如： public class UserServiceImpl implements UserService{
                public void  save(){
         System.out.println("保存 用户");
}
        public void delete(){
          System.out.println("删除 用户");
}
        public void update(){
         System.out.println("更新用户");
}
        public void find(){
         System.out.println("查找用户");
}
}

3.准备通知

   public class MyAdvice{

    //前置通知：目标方法运行之前 调用
   //后置通知：目标方法运行之后 调用（如果出现异常不会调用）
 //环绕通知：在目标方法运行之前和之后都调用
  //异常拦截通知：如果出现异常就会调用
  //后置通知（无论是否出现异常都会调用，在目标方法运行之后调用

  //前置通知
  public void before(){
   System.out.println("这是前置通知");
}
   //后置通知
  public void after(){
   System.out.println("这是后置通知");
}
  //环绕通知
  public Object around(ProceedingJoinPoint pjp) throws Throwable{
    System.out.println("这是环绕通知之前的部分");
     Object proceed=pjp.proceed();//调用目标方法
    System.out.println("这是环绕通知之后的部分");
    return proceed;
}
 //异常通知
 public void afterException(){
   System.out.println(“出异常了");
}
 //后置通知
  public void after(){
   System.out.println("这是后置通知 出现异常也会调用");
}
   
4.配置进行织入，将通知织入目标对象中

  <!--准备工作：导入AOP（约束）命名空间-->
 <!--配置 目标对象-->
  <bean name="userService" class="cn.itcast.service.UserServiceImpl"></bean>
<!--2.配置通知对象-->
  <bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice"></bean>
    
<aop:config>
 <!--配置切入点
 public void cn.itcast,service.UserServiceImpl.save()
  void cn.itcast.service.UserServiceImpl.save()
  * cn.itcast.service.UserServiceImpl.save()
  * cn.itcast.service.UserServiceImpl.*()
 *cn.itcast.servie.*ServiceImpl.*(..)
 *cn.itcast.servie.*ServiceImpl.*(..)
 -->
 <aop:pointcut expression="exepression(*cn,itcast.service.*ServiceImpl.*（..)) id="pc"/>
 <aop:aspect ref="myAdvice">
  <!--指定名为before方法作为前置通知-->
 <aop:before method="before" pointcut-ref="pc"/>
  <!--后置-->
<aop:after method="afterReturning" pointcut-ref="pc"/>
<!--环绕通知-->
<aop:around method="around" pointcut-ref="pc"/>
<!--异常拦截-->
<aop:after-throwing method="afterException" pointcut-ref="pc"/>
<!--后置-->
<aop:after method="after" pointcut-ref="pc"/>
 </aop:aspect>
</aop:config>

复习；
一、注解代替XML配置
  准备工作：
   导包：4+2   +spring-aop包
     xml中导入context约束
   在xml中开启扫描包中类的注解

  注解：
   @Component("BeanName")
    子注解
         @Controller（"BeanName")控制层
         @Service("BeanName")业务层
        @Repository("BeanName")持久层
    @Scope 指定对象的作用域
          singleton 单例
          prototype 多例
   @Value 值类型属性注入
    @AutoWired 自动属性注入，根据类型注入
   @Qulifier 指定注入的对象名称
   @Resource 指定对象的名称注入
   @PostConstruct 初始化方法
   @PreDestroy 销毁方法
         
二、Spring AOP开发

  aop思想：纵向重复，横向抽取
    filter中
    动态代理
    interceptor中
 String AOP：封装了动态代理技术，来体现AOP
   Spring AOP实现：可以对所有对象进行代理
      动态代理 代理需要实现接口
      cglib代理，对目标对象继承代理
 Spring AOP 名词
 Joinpoint：连接点，所有可以织入通知的方法
 Pointcut：切入点，已经织入通知的方法
 advice：需要增强的代码
 weaving：将通知应用的切点的过程
 target：目标对象
 proxy：代理对象
 aspect：切面，切入点+通知

步骤：
  1.导包 4+2
     2：aop+aspcet
     2：aop联盟+weaving
  2.目标对象
 
  3.准备通知类
    
     前置通知
     后置通知（方法正常结束后执行）
     环绕通知
     异常拦截通知
     后置通知（无论如何都执行）
  4.配置文件中进行配置，导入aop约束
     1）目标对象
     2）通知对象
     3）<aop:config>
            <aop:point-ref="切点名称随便写" expression="切点表达式"/>
           <aop:aspect ref="通知对象的名称">
               <aop:before method="" pointcut-ref=""/>
               
        <aop:after-returning method="" pointcut-ref=""/>
        <aop: around method="" pointcut-ref=""/>
        <aop:throwing  method="" pointcut-ref=""/>
         <aop:after method="" pointcut-ref=""/>

           </aop:aspect/>
           </aop:config>

                 
                Spring day-03
一、Spring整合JDBC
　　　Spring中国提供了一个可以操作数据库的对象，该对象封装了　JDBC技术
　　这个对象叫　JDBCTemplateJDBC模板对象
    与DBUtils中的QueyRunner非常相似
   准备工作：
  1）导包： 4+2  
     spring-test
     spring-aop
     c3p0连接池
    JDBC驱动
    spring-jdbc
    spring-tx

//准备连接池，注意要导入数据库连接池的jar包，c3p0....jar包
 CompooledDateSource datasource=new ComPooledDataSource
  datasource.setDriverClass("com.jdbc.mysql.Driver");
  datasource.setJdbcUrl("jdbc:mysql:///数据库名");
  datasource.setUser("root");
  datesource.setPasswore("1996502");

创建JDBC模板
 JdbcTemplate jt=new JdbcTemplate();
 jt.setDataSource(dataSource);
//书写sql语句
 String sql="insert into 表名 （字段名列表） vlaues (值列表);

<!--将连接池放入Spring容器中-->
<bean name="dataSource" class="">
  <property name="" value=""></property>
 <property name="" value=""></property>

 <property name="" value=""></property>
 <property name="" value=""></property>
 <property name="" value=""></property>
</bean>
<!--将JDBCTemplate模板对象放入Spring容器中-->
<bean id="" class="">



  Spring管理事务的三种方式
1.编码式
步骤：
  1）PlatformTransactionManager接口
<!--事务核心管理器 ，封装了所有事务操作，依赖于连接池-->
<bean name="" class="dataSource类的全包名">
    <property name="" ref=""></property>
</bean>
<!--事务模板对象-->
<bean name="" class="">
   <property name=""  ref="">
</bean>
2.XML配置（AOP）
3.注解配置（AOP）