SSH框架之Spring第二篇

1.1 基于注解的ioc配置
        既注解配置和xml配置要实现的功能都是一样的,都是要降低程序间的耦合.只是配置的形式不一样.
    
    1.2 环境搭建
        1.2.1 第一步:拷贝必备的jar包
        需要多拷贝一个spring-aop-4.2.4.release.jar
        1.2.2 创建xml文件,导入约束
            <?xml version="1.0" encoding="utf-8"?>
            <!-- 导入schema 
            约束的位置在:
                ..\spring-framework-4.2.4.release\docs\spring-framework-reference\html\xsd-configuration.html
                文件中。
            注意：要导入schema约束
            -->
            <beans xmlns="http://www.springframework.org/schema/beans"
                  xmlns:context="http://www.springframework.org/schema/context"
                   xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
                   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 ">
            </beans>
        1.2.3 使用@component注解配置管理的资源
            /**
             * 客户的业务层实现类
             * @author zhy
             * 
            @component(value="customerservice")
            public class customerserviceimpl implements icustomerservice {
                @override
                public void savecustomer() {
                    system.out.println("执行了保存客户");
                }
            }
        1.2.4 第四步在spring的配置文件中开启spring对注解ioc的支持
            <!--告知spring框架在,读取配置文件,创建容器时,扫描注解,依据注解创建对象,并存入容器中.>
                <context:component-scan base-package="com.baidu"></context:component-sacn>
    1.3 常用注解
        1.3.1 用于创建对象的
            相当于 : <bean id="" class="">
        1.3.1.1 @component
            作用:
                把资源让spring来管理.相当于在xml配置一个bean.
            属性:
                value: 指定bean的id.如果不指定value属性,默认bean的id是当前类的类名.首字母小写.
        1.31.2 @controller @service @repository
            们三个注解都是针对一个的衍生注解，他们的作用及属性都是一模一样的。
            他们只不过是提供了更加明确的语义化。
                @controller：一般用于表现层的注解。
                @service：一般用于业务层的注解。
                @repository：一般用于持久层的注解。
            细节：如果注解中有且只有一个属性要赋值时，且名称是value，value在赋值是可以不写。
        1.3.2 用于注入数据的
            相当于 : <property name="" ref="">  或者 <property name="" value="">
            1.3.2.1@autowired
            作用：
                自动按照类型注入。当使用注解注入属性时，set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时，使用要注入的对象变量名称作为bean的id，在spring容器查找，找到了也可以注入成功。找不到就报错。
                /**
                 *     @autowired    自动装配，自动按类型注入对象
                 *     <bean id="userservice" class="com.baidu.demo2.userserviceimpl" scope="" init-method="init">
                 *         <property name="userdao" ref="ud"/>
                 *     </bean>
                 *     
                 *     @autowired
                    @qualifier(value="userdao")    这2个注解必须要一起使用，按id名称注入
                    
                    @resource    是java提供注解，spring容器支持该注解。可以通过name在容器中查找指定名称的对象
                 *     
            1.3.2.2@qualifier
            作用：
                在自动按照类型注入的基础之上，再按照bean的id注入。它在给字段注入时不能独立使用，必须和@autowire一起使用；但是给方法参数注入时，可以独立使用。
            属性：
                value：指定bean的id。
            1.3.2.3@resource
            作用：
                直接按照bean的id注入。它也只能注入其他bean类型。
            属性：
                name：指定bean的id。
            1.3.2.4@value
            作用：
                注入基本数据类型和string类型数据的
            属性：
                value：用于指定值
            1.3.3用于改变作用范围的：
                相当于：<bean id="" class="" scope="">
            1.3.3.1@scope
            作用：
                指定bean的作用范围。
            属性：
                value：指定范围的值。
                       取值：singleton  prototype request session globalsession
            1.3.4和生命周期相关的：(了解)  
                相当于：<bean id="" class="" init-method="" destroy-method="" />
            1.3.4.1@postconstruct
            作用：
                用于指定初始化方法。
            1.3.4.2@predestroy
            作用：
                用于指定销毁方法。
            1.3.5代码示例
            业务层代码：
            /**
             * 客户的业务层接口
             */
            public interface icustomerservice {    
                /**
                 * 保存客户
                 * @param customer
                 */
                void savecustomer();    
            }


            /**
             * 客户的业务层实现类
             */
            //作用就相当于在xml中配置了一个bean标签，该注解有value属性，含义是bean的id。
            //不写的时候，默认的id是：当前类名，且首字母小写。即：customerserviceimpl
            @component(value="customerservice")
            @scope(value="singleton")
            public class customerserviceimpl implements icustomerservice {
            //    @autowired
            //    自动按照数据类型注入，拿着当前变量的数据类型在spring的容器中找，找到后，给变量赋值。
            //    当有多个类型匹配时，会使用当前变量名称customerdao作为bean的id，继续在容器中找。
            //    找到了，也能注入成功。找不到就报错。
            //    @qualifier(value="customerdao2")//在自动按照类型注入的基础之上，再按照id注入
                @resource(name="customerdao2")//直接按照bean的id注入
                private icustomerdao customerdao = null;
                
                @value("com.mysql.jdbc.driver")//注入基本类型和string类型数据
                private string driver;

                @override
                public void savecustomer() {
                    system.out.println(driver);
                    customerdao.savecustomer();    
                }
            }


            持久层代码：
            /**
             * 客户的持久层接口
             */
            public interface icustomerdao {
                /**
                 * 保存客户
                 */
                void savecustomer();
            }



            /**
             * 客户的持久层实现类11111111111111111111
             */
            @repository("customerdao1")
            public class customerdaoimpl implements icustomerdao {

                @override
                public void savecustomer() {
                    system.out.println("保存了客户111111111111111111");
                }
            }

            /**
             * 客户的持久层实现类222222222222222222222222
             */
            @repository("customerdao2")
            public class customerdaoimpl2 implements icustomerdao {

                @override
                public void savecustomer() {
                    system.out.println("保存了客户2222222222222222222");
                }
            }

            测试类代码:
            public class client {
                public static void main(string[] args) {
                    //1.获取容器
                    applicationcontext ac = new classpathxmlapplicationcontext("bean.xml");
                    //2.根据id获取对象
                    icustomerservice cs = (icustomerservice) ac.getbean("customerservice");                cs.savecustomer();
                }
            }

            配置文件：
            <?xml version="1.0" encoding="utf-8"?>
            <!-- 我们导入约束时，除了昨天的那部分之外，还要单独导入一个context名称空间 -->
            <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">
                <!-- 告知spring框架在通过读取配置文件创建容器时，扫描的包，并根据包中类的注解创建对象-->
                <context:component-scan base-package="com.baidu"></context:component-scan>
            </beans>
        
        1.3.6 关于spring注解和xml的选择问题
            注解的优势 :
                配置简单,维护方便(我们找到类,就相当于找到了对应的配置)
            xml的优势  :
                修改时,不用改源码.不涉及重写编译和部署.
            spring管理bean方式的比较 :
                            基于xml配置                        基于注解配置
                bean定义    <bean id="..." class="..">        @component    衍生类@repository    @service     @controller
                bean名称    通过id或name指定                @component("person")
                bean注入    <property>或者通过p命名空间        @autowired按类型注入    @qualifier按名称注入
                生命过程,        init-method destroy-method    @postconstruct初始化    @predestroy销毁    @scope设置作用范围
                bean作用范围    范围scope属性                
                适合场景        bean来自第三方,使用其它        bean的实现类由用户自己开发
    1.5 spring的纯注解配置
        /**
             * 客户的业务层实现类
             */
            @configuration//表明当前类是一个配置类
            @componentscan(basepackages = "com.baidu")//配置要扫描的包
            public class springconfiguration {
            }

            那么新的问题又来了，我们如何获取容器呢？
            public class client {
                public static void main(string[] args) {
                    //1.获取容器：由于我们已经没有了xml文件，所以再用读取xml方式就不能用了。
                    //这时需要指定加载哪个类上的注解
                    applicationcontext ac = 
                        new annotationconfigapplicationcontext(springconfiguration.class);
                    //2.根据id获取对象
                    icustomerservice cs = (icustomerservice) ac.getbean("customerservice");
                    cs.savecustomer();
                }
            }
            1.5.3新注解说明
            1.5.3.1@configuration
            作用：
                用于指定当前类是一个spring配置类，当创建容器时会从该类上加载注解。获取容器时需要使用annotationapplicationcontext(有@configuration注解的类.class)。
            属性：
                value:用于指定配置类的字节码
            示例代码：
            /**
             * 用于初始化spring容器的配置类
             */
            @configuration
            public class springconfiguration{
            }
            1.5.3.2@componentscan
            作用：
                用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的：
            <context:component-scan base-package="com.baidu"/>是一样的。
            属性：
                basepackages：用于指定要扫描的包。和该注解中的value属性作用一样。
                    
        1.5.3.4@import
            作用：
                用于导入其他配置类，在引入其他配置类时，可以不用再写@configuration注解。当然，写上也没问题。
            属性：
                value[]：用于指定其他配置类的字节码。
                示例代码：
            @configuration
            @componentscan(basepackages = "cn.baidu.spring")
            @import({ configuration_b.class})
            public class configuration_a {
            }

            @configuration
            @propertysource("classpath:info.properties")
            public class configuration_b {
            }
        1.5.3.5@bean
            作用：
                该注解只能写在方法上，表明使用此方法创建一个对象，并且放入spring容器。它就相当于我们之前在xml配置中介绍的factory-bean和factory-method。
            属性：
                name：给当前@bean注解方法创建的对象指定一个名称(即bean的id）。
                示例代码：
            @bean(name = "datasource2")
                public datasource createds() throws exception {
                    combopooleddatasource combopooleddatasource = new combopooleddatasource();
                    combopooleddatasource.setuser("root");
                    combopooleddatasource.setpassword("1234");
                    combopooleddatasource.setdriverclass("com.mysql.jdbc.driver");
                    combopooleddatasource.setjdbcurl("jdbc:mysql:///spring_ioc");
                    return combopooleddatasource;
                }
        单元整合
            /**
             * spring整合junit单元测试
             * @author administrator
             */
            @runwith(value=springjunit4classrunner.class)
            @contextconfiguration(value="classpath:applicationcontext.xml")
            public class demo1 {
                
                // 测试哪个对象，可以使用resource注解把对象注入进来
                @resource(name="userservice")
                private userservice userservice;
                
                @resource(name="userdao")
                private userdao userdao;
                
                /**
                 * spring 整合juint单元测试的方法
                 */
                @test
                public void run3(){
                    userservice.save();
                }
                
                @test
                public void run4(){
                    // userservice.update();
                    userdao.save();
                }
        使用xml方式完成ioc的入门
            1. 导入jar包
            2. 编写接口和实现类
            3. 编写配置文件,管理实现类
            4. 编写入门的程序
        使用注解的方式完成ioc的入门
            1. 导入jar包
            2. 编写接口和实现类
            3. 编写applicationcontext.xml配置文件,目的 : 让注解生效
            4. 在实现类上编写注解
            5. 编写入门的程序
        
        1. 管理类的
            @component         所有类都可以使用
            @controller        web层使用的注解,就是action使用的.
            @service         业务层使用的注解
            @repository        持久层使用的注解
        2. 依赖注入的注解 (set方法可以省略不写)
            @value            给普通类型属性注入值(string int double)
            @resource        给引用类型注入值的,强调 : 该注解的属性时name
            @scope            对象作用范围,默认单例的.
            
        spring整合web
            servletcontext对象,服务器启动就创建,服务器关闭就销毁.
            监听器 : 监听servletcontext域对象的创建和销毁的.
            servletcontextlistener监听器 , init destory
            总结 :
                服务器启动后,spring创建对象,spring创建web版本的工厂,把工厂保存到servletcontext域对象中.
            编写 :
                从servletcontext对象中获取到web版本的工厂,从工厂中获取到service对象,调用方法.