Spring 学习笔记

原先的 Spring 学习的时候的笔记 整理了一下    觉得还行  简单实用  共享一下


  1  要点记录   
    
spring Ioc 
{    
    
    
    1   spring bean 在反射创建对象后  使用的是单例模式！ 存在数据安全的问题   
        属性是被共享的！
            如果该属性有数据，会引起线程安全的问题！
        <bean id="helloWorid" class="cn.itcast.springTest.HelloWorid" scope="prototype" >  </bean>
        可以通过 XML 配置来设置   spring 默认是 单例的 scope="prototype" 就变成了 多例的了
        
    2       <bean id="personService" class="com.myapp.core.beanscope.PersonService" scope="singleton"  init-method="init"  destroy-method="cleanUp">   
    
        nit-method 是设置  spring 在创建bean节点里面的 对象 时 初始化的时候 调用的方法   
                注：  在构造 或 静态 后面调用
        destroy-method 是设置 bean 节点创建的对象 在销毁的时候 调用的方法      
                注：  如果是多例 的时候 spring 不负责销毁动作    
                
        
        
    3   spring 容器 （反射出的类对象） 的  三种初始化方法
    
        3.1    默认的是 调用 无参的构造函数
        
        3.2     factory-method=“”  需要创建类中的 方法      通过该方法的到返回的类型
           实例：
                    public class HelloWorldFactory {
                        public static HelloWorld getInstance(){
                            return new HelloWorld();
                        }
                    }
         
    
    4   spring 中 只要声明一个 bean 节点 运行的时候就会创建一个对象
    
    
    5   spring 在启动的时候  spring 容器配制中的类 就已经创建完成了！
    
    6   控制容器中的类创建时候 
            lazy-init 这个属性中设置 
                <bean id="helloWorid" class="cn.itcast.springTest.HelloWorid" lazy-init="true"  ></bean>
        在启动spring容器的时候，spring容器配置文件中的类就已经创建完成对象了
                lazy-init
                   default  false
                   true  在context.getBean的时候才要创建对象
                      *  优点
                                    如果该bean中有大数据存在，则什么时候context.getBean,什么时候创建对象
                                    可以防止数据过早的停留在内存中，做到了懒加载
                      *  缺点
                                     如果spring配置文件中，该bean的配置有错误，那么在tomcat容器启动的时候，发现不了
                   false 在启动spring容器的时候创建对象
                      *  优点
                                     如果在启动tomcat时要启动spring容器，
                                     那么如果spring容器会错误，这个时候tomcat容器不会正常启动
                      *  缺点
                                      如果存在大量的数据，会过早的停留在内存中
         <bean id="helloWorld" class="cn.itcast.spring0909.createobject.when.HelloWorl" lazy-init="true"></bean>
         <bean id="person" class="cn.itcast.spring0909.createobject.when.Perso" lazy-init="true"></bean>    
         
         
         
         
    总结：
         spring的IOC ：
                1   IOC ：spring容器控制对象的生命周期  ； 前提条件 ：在容器中的bean 必须是单例
                    1.1 ： 创建
                        1.1.1  ： 方式
                                  利用默认的构造函数
                                  利用静态工厂方法
                                  利用实例工厂方法
                        1.1.2  ： 时机
                                  lazy-init 为"default/false" 当启动 spring 容器的时候 创建bean
                                       但是如果bean 是 prototype（多例） 时，特殊。这种情况无效
                                   
                                   ps：在spring启动的时候就会发现错误 ，有肯能照成一些数据长时间的驻留在内存中
                                   
                                  lazy-init 为"true" 当context。getBean时创建      
                                        bean为多例时，必须用这种方式创建对象
                                   
                                   PS： 不能及时发现错误， 数据会在需要的时候加载
                                        
                    1.2 ： 初始化
                        1.2.1  ： 由spring容器调用init 方法， 在构造函数之后执行
                        
                        
                    1.3 ： 销毁
                        1.3.1  ：  如果是单利，则必须返回CalssPathXmlApplicationContext该容器，才能执行销毁
                        1.3.2  ： 如果是多例，则容器不负责销毁
                        
}

spring DI 依赖注入  
{
    
    定义： 给属性赋值就是依赖注入
    
    1.1 利用Set来赋值
    {
     <bean id="person" class="cn.spring.di.xml.set.Person">
        <!-- 
            property就是代表属性
              在spring中基本类型(包装类型和String)都可以用value来赋值
                                     引用类型用ref赋值
         -->
        <property name="pid" value="5"></property>
        <property name="pname" value="王二"></property>
        <property name="student">
            <ref bean="student"/>
        </property>
        <property name="lists">
            <list>
                <value>list1</value>
                <value>list2</value>
                <ref bean="student"/>
            </list>
        </property>
        <property name="sets">
            <set>
                <value>set1</value>
                <value>set2</value>
                <ref bean="student"/>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="map1">
                    <value>map1</value>
                </entry>
                <entry key="map2">
                    <value>map2</value>
                </entry>
                <entry key="map3">
                    <ref bean="student"/>
                </entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="prop1">
                    prop1
                </prop>
            </props>
        </property>
    </bean>
    }

    1.2 利用构造函数赋值
    {
        <bean id="person" class="cn.spring.di.xml.constructor.Person">
        <!-- 
            构造函数的参数
              index  第几个参数，下标从0开始
              type   参数的类型
              ref    如果类型是引用类型，赋值
              value  如果类型是基本类型，赋值
             说明：
                只能指定一个构造函数
         -->
        <constructor-arg index="0"  type="java.lang.String" value="露露"></constructor-arg>
        <constructor-arg index="1"  ref="student"></constructor-arg>
        </bean>
    
       <bean id="student" class="cn.spring.di.xml.constructor.Student"></bean>
        
        类：
          public Person(Long pid,String pname){
                this.pid = pid;
                this.pname = pname;
          }
    
          public Person(String pname,Student student){
                this.pname = pname;
                this.student = student;
          }
        
    }
        
     
}


IOC 和DI 做了什么事情？
   
    * 创建对象
    * 给对象赋值
    
IOC 和DI 的意思
    
    * 可以在类中引用一个接口，而给接口赋值的工作交给spring容器来做，程序员只需要在配置文件中做一些配置就行。
    这样在客户端做到了 完全的 面向接口编程
    
    

    
spring AOP :

{
   * AOP 的核心就是动态代理；
        其实就是 为目标类 方法进行一次包装 ， 在方法执行前 和之后 触发其他模块方法执行
        
   * springAOP的各个概念:
      
       1. 切面：  
            切面指的就是 对目标类方法包装 时  提前或之后执行的方法的 类对象
       2. 通知： 
            指得是       对目标类方法包装 时  提前或之后执行的方法
       3. 切入点：
            指的是  只有符合切入点，才能把通知和目标方法结合在一起 就是一个对目标方法的一个验证   
       4. 连接点：
            指的是  客户端调用的方法  也就是具体调用的方法
            
    *  代理对象的方法=通知+目标方法
    *  aop:做到了代码块的重用 

    
    关于SpringAOP的 配置 从spring_aop示例中找寻
    
    关于切入点表达式 从 spring.xls 表格中找寻
    
    
    
    springAOP 的原理：
    
    
         
          *  加载配置文件，启动spring容器
          *  spring容器为bean创建对象
          *  解析aop的配置，会解析切入点表达式
          *  看纳入spring管理的那个类和切入点表达式匹配，如果匹配则会为该类创建代理对象
          *  代理对象的方法体的形成就是目标方法+通知
          *  客户端在context.getBean时，如果该bean有代理对象，则返回代理对象，如果没有代理对象则返回原来的对象
          
          
     * 说明：
          如果目标类实现了接口，则spring容器会采用jdk proxy, 如果目标类没有实现接口，则spring容器会采用    cglibproxy     
        
    
    
    
    PS:  有参数的通知方法：
    
        通知有 前置 后置 异常 最终 环绕 这些类型
        
        通长自己写的通知方法是用的是 无参方法， 如果需要获得  连接点 也就是客户端调用方法   的信息的时候  使用有惨方法
        
        示例：
        {
        
        /**
         * 前置通知
         *    通过JoinPoint获取连接点的信息
        */
        public void beginTransaction(JoinPoint joinPoint){
            joinPoint.getArgs();//获取方法的参数
            String methodName = joinPoint.getSignature().getName();
            System.out.println(methodName);
            System.out.println("begin transaction");
        }
        /**
         * 后置通知  ，Object val 是返回值
         *  注意  在配置文件中   配置的后置通知XML 中 returning=”var“ 
         *  那么 定义方式的时候  返回值名称也得 和 配置文件中相同
         *
         *  如果目标方法遇到异常 ，改通知将不执行
         *
         */
        public void commit(JoinPoint joinPoint,Object val){
            List<Person> personList = (List<Person>)val;
            System.out.println(personList.size());
            System.out.println("commit");
        }
        /**
         * 最终通知  // 在目标方法执行之后  
         * 无论目标方法是否遇到异常 ，都执行     经常做一些关闭资源的动作
         */
        public void finallyMethod(){
            System.out.println("finally method");
        }
        
        /**
         * 异常通知
         */
        public void exceptionMethod(Throwable ex){
            System.out.println(ex.getMessage());
        }
        /**
         * 环绕通知
         *     能控制目标方法的执行      相当于拦截器方法  
         * @param joinPoint = 客户端调用的方法  
         * @throws Throwable 
         */
        public void aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable{
            System.out.println("aaaa");
            // 获取客户端调用方法的名称
            String methodName = joinPoint.getSignature().getName();
            // 判断是否是 期望的方法
            if("savePerson".equals(methodName)){
                // 是 就让 客户端调用的方法执行
                joinPoint.proceed();//
            }
            // 否  客户端方法  不执行
        }
        
        
        }    
        
    PS: 前置通知 和 后置通知 只能在目标方法中 添加内容 ，但是控制不了方法的指向
    
    重要提示：   通知是通过 配置文件的从上往下 执行的！  
}    
    
    

 

spring 中的   注解器 使用和运行机制

  
    PS： @Resource 这个注解类 是最常用的  
    
 
    
    依赖注入的注解解析器
    
{    
     原理
      
         *  启动spring容器，并且加载配置文件
         *  会为student和person两个类创建对象
         *  当解析到<context:annotation-config></context:annotation-config>
            会启动依赖注入的注解解析器
         *  会在纳入spring管理的bean的范围内查找看哪些bean的属性上有@Resource注解
         *  如果@Resource注解的name属性的值为"",则会把注解所在的属性的名称和spring容器中bean的id进行匹配
            如果匹配成功，则把id对应的对象赋值给该属性，如果匹配不成功，则按照类型进行匹配,如果再匹配不成功，则报错
         *  如果@Resource注解的name属性的值不为"",  会把name属性的值和spring容器中bean的id做匹配，如果匹配
            成功，则赋值，如果匹配不成功 ，则直接报错
     * 说明：
     *    注解只能用于引用类型
     * @author Administrator
     *
     
     
     实例： 
    {
        
        <!-- 
        1、导入命名空间 
            xmlns:context="http://www.springframework.org/schema/context" 
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-2.5.xsd 
        2、导入依赖注入的注解解析器 
            <context:annotation-config></context:annotation-config>
        3、把student和person导入进来 
    -->
        <context:annotation-config></context:annotation-config>
        <bean id="student" class="cn.spring.di.annotation.Student"></bean>
        <bean id="person" class="cn.spring.di.annotation.Person"></bean>
            
        
        
        public class Person {
            @Resource(name="student")
            //@Autowired//按照类型进行匹配
            //@Qualifier("student")
            private Student studen;
            
        }
        public class Student {
                public void say(){
                    System.out.println("student");
                }
        }
        
    }
}
    
    类扫描的注解解析器
{     
     
     原理
        *  启动spring容器，加载配置文件
        *  spring容器解析到
              <context:component-scan base-package="cn.spring.scan"></context:component-scan>
     *   *  spring容器会在指定的包及子包中查找类上是否有@Component
     *   *  如果@Component注解没有写任何属性
     *        @Component
     *        public class Person{
     *        
     *        }
     *        ==
     *        <bean id="person" class="..Person">
     *      如果@Component("aa")
     *        @Component
     *        public class Person{
     *        
     *        }
     *        ==
     *        <bean id="aa" class="..Person">
     *    *  在纳入spring管理的bean的范围内查找@Resource注解
     *    *  执行@Resource注解的过程
     *  说明：
     *     xml效率比较高，但是书写比较麻烦
     *     注解效率比较低，书写比较简单
     *     不推荐实用 类扫描注解解析器  Spring Ioc 的目的就是解耦  如果控制 还在代码中写死  这种意义就不大  同时也不方便 阅读代码
     *
     
    实例 
    {
        <!-- 
        1、导入命名空间 
            xmlns:context="http://www.springframework.org/schema/context" 
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-2.5.xsd 
        2、启动类扫描的注解解析器
        3、启动依赖注入的注解解析器
        -->
        
        <!-- 
            component就是bean
            base-package
               会在base-package的值所在的包及子包下扫描所有的类
         -->
        <context:component-scan base-package="cn.spring.scan"></context:component-scan>
            
            
        
        @Component("perso")
        public class Person {}
        @Component
        public class Student {}
            
            
            
        
    }
    
    
    
     

     
}

    使用构造器 来控制 bean 加载的  初始化 和 销毁  方法，
    
    实例：
{
        
        @PostConstruct // 类构造器之后调用
        public void init(){
            System.out.println("init");
        }
        
        @PreDestroy   //  在销毁动作之前调用
        public void destroy(){
            System.out.println("destroy");
        }
        
}
    
    
    PS: 如果一个类中有 基本类型 ，并且 基本类型是spring的形式来赋值。 这个时候必须使用XML来赋值，不能使用注解 赋值
    
    PS: 不推荐使用 类型匹配  也就是  
    {
        @Resource  
        private  Student studenA;
        这里找的是 bean  的 class 的值  
        
        如果定义多个bean class 的值 相同  那么就会报错 因为不确定是哪一个 bean 
        
     
        
    }
    
    
    
spring容器中的继承问题

   1.1.1  默认情况下   即便给是 父类的属性注入了 对应的值  ，但是子类 并不会 的到父类的值
    
      解决方法：
     
         parent  ： 让子类拥有父类属性的值
       
         <bean id="person" class="cn.springTest.Person" parent="personBase"></bean>  
         
         同样 可以让子类拥有父类的属性  自己赋值  不用写 parent 属性
          <bean id="student" class="cn.spring.extend.Student">
               <property name="name" value="aaaaa"></property>
          </bean>
    
    
     
        abstract
           spring容器不会为该类创建对象
      
            <bean id="person" class="cn.spring.extend.Person" abstract="true">
                <property name="name" value="王二的哥"></property>
            </bean>
    
    
    
Spring 事物问题：


{
   *   详情请看 JDBC     / transaction 文件下的示例 
   
   *    关键点
   
    <!-- 声明事务通知 id事务标识 transaction-manager -->
    <!-- 事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.
            DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    
    Ps :  id="transactionManager" 的Class  是 一个继承了一个抽象父类的 子类   目的是为了多态，由子类告诉Spring 使用数据库是那种技术
    
    
    <!-- 声明目标方法中哪些方法需要事务，哪些不需要事务 -->
    <tx:advice id="tx" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- name 限定方法的名称 isolation 隔离机制 propagation 传播机制 ready-only 只读 -->
            <tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED"
                read-only="false" />
        </tx:attributes>
    </tx:advice>
    
    
    PS:  propagation 传播机制  基本用的都是默认的 REQUIRED  指得是 一个方法中如果有多个事物方法 ，那么就把第一个事物方法后面的事物方法逐个附加到第一个事物方法中。  启动一次事物就行！
    
    
    <!-- spring容器做的事情 -->
    <aop:config>
        <aop:pointcut
            expression="execution(* cn.spring.jdbc.transaction.
                PersonServiceImpl.*(..))"
            id="perform" />
            
        Ps:  声明一个切面 的 触发点  
        
        <aop:advisor advice-ref="tx" pointcut-ref="perform"/>
        
        Ps:  不需要自己声明切面类，  直接 创建切面 通知  指定到 事物方法
    </aop:config>
    Ps: 不经常写可能会 忘记怎么写   我的方式是 从下上往上写  先写 <aop:config> --> <tx:advice>--><bean>
}    
    
    
    
    
    
Spring dataSource  定义数据库连接类的两种方式 

  *  
  
    <!-- 产生dataSource -->
    <bean
        class="org.springframework.beans.factory.
            config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>classpath:jdbc.properties</value>
        </property>
    </bean>
    <bean id="dataSource" destroy-method="close"
        class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    PS: 读取 classpath:jdbc.properties  这个路径中 的 properties 配置文件中相同，将配置文件中对应的值赋
  
    * properties 配置文件中的数据
        jdbc.driverClassName=com.mysql.jdbc.Driver
        jdbc.url=jdbc\:mysql\://localhost\:3306/hibernate
        jdbc.username=root
        jdbc.password=root

    
    

    
  *   

    <!--  配置dbcp的数据库连接池   -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/hibernate" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    
    
    
    
    
经验：

    使用 AOP后  测试的时候 首先第一个先检查 获取的对象是否是个代理对象
    
    
    配置Spring 文件的时候   思路
     程序员 做什么
     spring 做什么 
     
     
    
    关于  切面点 需要适用于 多个 包 的问题
      
    expression="execution(* cn.spring.*.transaction.PersonServiceImpl.*(..))"
            id="perform" />
            
    适用通配符 *  来模糊匹配 结节这个问题