一、Spring作用

    1.生态体系庞大,全能型选手!【springmvc是其一个子模块,jdbcTemplate能直接操作数据库!】
    2.将其他组件粘合在一起
    3.IOC容器和AOP[Aspect Oreinted Programming]:
        Spring的Ioc[Inverse of Controller]机制(控制反转和依赖注入)正是用在此处。
        Spring的Ioc(控制反转和依赖注入)
             控制反转[Ioc]:就是由容器控制程序之间的(依赖)关系,而非传统实现中,由程序代码直接操控。
             控制反转是一种思想,其具体实现就是依赖注入!
             依赖注入[DI:Dependency Injection]:组件之间的依赖关系由容器在运行期决定,由容器动态的将某种依赖关系注入到组件之中。

二、搭建Spring IOC容器需要的开发环境

   1.导入IOC容器需要的jar包
        spring-beans-4.0.0.RELEASE.jar
        spring-context-4.0.0.RELEASE.jar
        spring-core-4.0.0.RELEASE.jar
        spring-expression-4.0.0.RELEASE.jar
        commons-logging-1.1.3.jar
   2.创建Spring配置文件[Spring bean Configuration File]
        applicationContext.xml
  

三、IOC容器创建对象步骤

    1.创建IOC容器对象
            private ApplicationContext ioc=new FileSystemXmlApplicationContext("C:\\Users\\Administrator\\Desktop\\applicationContext.xml"); //本地文件系统(磁盘)
           * private ApplicationContext ioc1=new ClassPathXmlApplicationContext("applicationContext.xml"); //src下
    
    2.使用IOC容器在创建对象的同时,给对象的属性赋值
   
       从IOC容器中获取对象就两种方式:1、通过id值获取bean对象
                      2、通过IOC容器中bean的类型获取bean对象

   <!--实验1:通过IOC容器创建对象,并为属性赋值  -->
    <!-- 需要由IOC容器创建对象的全类名 -->
    <!-- 为了便于从IOC容器中获取book对象,声明一个一个唯一的id值 -->
   <bean id="book01" class="com.neuedu.spring.bean.Book">
        <property name="bookId" value="2001"></property>
        <property name="bookName" value="三国演义"></property>
        <property name="author" value="罗贯中"></property>
        <property name="price" value="22.5"></property>
    </bean>
View Code

 

 @Test
        public void test01() {
            //1.创建IOC容器自身的对象
            //指定配置文件以类路径为基准的配置文件名
            ApplicationContext ioc= new ClassPathXmlApplicationContext("bean.xml");
            //2.从IOC容器中获取指定的对象
            Object bean = ioc.getBean("book01");
            System.out.println(bean);
        }
View Code

 

注意:
    ①IOC容器本身对象创建时,会将配置文件中配置好的bean先创建出来
    ②默认是单实例的,只创建bean的一个对象
    ③如果设置bean的scope属性为prototype,那么创建bean的对象就是多实例的,在获取的时候创建,每次获取对象都会创建新的
    ④.从IOC容器中获取对象
        ①根据bean的id获取
        ②根据bean的类型获取:要求容器中指定类型的bean是唯一的

bean的后置处理器:
    1.指的是在bean的初始化方法前后执行操作的专门的对象。
    2.自定义的后置处理器:
        1)需要实现接口:org.springframework.beans.factory.config.BeanPostProcessor .
        2) 做相应的配置就好!
   

   <!-- bean的后置处理器 -->
     <bean id="beanPostProcessor" class="com.neuedu.entity.MyBeanPostProcessor"></bean>
   
package com.neuedu.entity;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor{

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("===================================");
        System.out.println("BeforeInitialization:"+beanName+"="+bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("=============================");  
        System.out.println("AfterInitialization:"+beanName+"="+bean);
        return bean;
    }

     
}
View Code
        /*bean的后置处理器*/
    @Test
    public void test02() {
         Object bean = ioc.getBean("beanPostProcessor");
         System.out.println(bean);
    }            
View Code



配置FactoryBean★ 

    public class MyFactoryBean implements FactoryBean<Book> {

        @Override
        public Book getObject() throws Exception {
            return new Book(22, "无字天书", "好啊", 22.5);
        }

        @Override
        public Class<?> getObjectType() {
            return Book.class;
        }

        @Override
        public boolean isSingleton() {
            return false;
        }

    }

测试bean的作用域,分别创建单实例和多实例的bean★

   <!-- scope属性为prototype,那么创建bean的对象就是多实例的 -->
   <bean id="user" class="com.neuedu.entity.User" scope="prototype">
           <property name="id" value="user01"/>
           <property name="name" value="Danny"/>
           <property name="age" value="23"/>
   </bean>
   <!-- scope属性为singleton为默认值,默认是单实例的,只创建bean的一个对象 -->
   <bean id="user" class="com.neuedu.entity.User" scope="singleton">
           <property name="id" value="user01"/>
           <property name="name" value="Danny"/>
           <property name="age" value="23"/>
   </bean>

 
实验22:创建带有生命周期方法的bean

  <!--创建带有生命周期方法的bean -->
   <bean id="lifeObject" class="com.neuedu.entity.LifeObject" init-method="initMethod" destroy-method="destroyMethod" />

 
实验22[补充]:测试bean的后置处理器
    ①在bean的初始化方法调用前后执行操作的专门的对象
    ②自定义后置处理器实现该接口:org.springframework.beans.factory.config.BeanPostProcessor
    ③在springmvc中配置一下该bean对象.
    <bean class="com.neuedu.spring.bean.Book" init-method="init"></bean>
    <bean id="myBeanPostProcessor" class="com.neuedu.spring.bean.MyBeanPostProcessor"></bean>
    
    批处理(batch)
        - 批处理指的是一次操作中执行多条SQL语句
        - 批处理相比于一次一次执行效率会提高很多
        
        - 批处理主要是分两步:
            1.将要执行的SQL语句保存
            2.执行SQL语句
            
        - Statement和PreparedStatement都支持批处理操作,这里我们只需要掌握PreparedStatement的批处理方式:
            - 方法:
                void addBatch()
                    - 将要执行的SQL先保存起来,先不执行
                    - 这个方法在设置完所有的占位符之后调用
                int[] executeBatch()
                    - 这个方法用来执行SQL语句,这个方法会将批处理中所有SQL语句执行
                    
        - mysql默认批处理是关闭的,所以我们还需要去打开mysql的批处理:
            ?    rewriteBatchedStatements=true
            我们需要将以上的参数添加到mysql的url地址中
            
        - 注意:低版本的mysql-jdbc驱动也不支持批处理
        

        
事务(Transaction)
        - 在开发中我们的一个业务往往需要同时操作多个表,这些操作往往是不可分割,业务中的对数据库的多次操作,
            要么同时成功,要么全都失败。
        - 注意:我们在同一个事务中使用的数据库连接(Connection)必须是同一个。    

        - 事务的特性(ACID):
              原子性(atomicity)
                    一个事务是一个不可分割的工作单位,事务中包括的诸操作要么都做,要么都不做。
                
               一致性(consistency)
                     事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

               隔离性(isolation)
                      一个事务的执行不能被其他事务干扰。
                          即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。
                    
              持久性(durability)
                     持久性也称永久性(permanence),指一个事务一旦提交,它对数据库中数据的改变就应该是永久。 接下来的其他操作或故障不应该对其有任何影响。
                    
        - 操作失误的基本步骤:
              1.开启事务
                  - 开启事务以后,我们只后的所有操作将都会在同一个事务当中
              2.操作数据库
                  - 开启事务以后再去操作数据库,所有操作将不会直接提交到数据库中
              3.提交事务
                  - 将修改应用到数据库
              4.回滚事务
                  - 数据库操作过程中出现异常了,回滚事务,回滚事务以后,数据库变成开启事务之前的状态
        
            - mysql中的事务控制
                #开启事务
                START TRANSACTION
            
                #回滚事务
                ROLLBACK
            
                #提交事务
                COMMIT
            
        - JDBC中的事务主要通过Connection对象来控制的
            1.开启事务
                void setAutoCommit(boolean autoCommit) throws SQLException;
                - 设置事务是否自动提交,默认是自动提交
                - 设置事务手动提交
                    conn.setAutoCommit(false);
                
            2.提交事务
                void commit() throws SQLException;
                - 提交事务
                conn.commit()
            
            3.回滚事务
                void rollback() throws SQLException;
                - 回滚事务
                conn.rollback()
                
        - 事务控制的格式:
         

           //创建一个Connection
            Connection conn = null;
            
            try{
                
                //获取Connection
                conn = JDBCUtils.getConnection();
                
                //开启事务
                conn.setAutoCommit(false);
                
                //对数据库进行操作
                
                //操作成功,提交事务
                conn.commit();
                
            }catch(Exception e){
                e.printStackTrace();
                
                //回滚事务
                try {
                    conn.rollback();
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
                
            }finally{
                JDBCUtils.close(conn, null, null);
            }

    

 


数据库连接池:
    6) 数据库连接池
        > 数据库连接池就是存放数据库连接(Connection)的集合
        > 我们获取一个数据库连接是一个相对很麻烦的过程,
            如果我们获取一个数据库连接,使用一次以后就给它关闭了
                下一次再去使用的时候就要重新创建一个新的数据库连接。
        > 所以我们提出了一个数据库连接池的概念,数据库连接池放的都是数据库连接(Connection)
            我们在去使用数据库连接时候,不用再去重新创建数据库连接,而是直接从池中获取,
                使用完的数据库连接,也不是直接销毁,而是要放回到连接池。
        > 数据库连接池的常见的属性:
        
            ?    初始连接数量:数据连接池创建以后,保存数据库连接的数量
            
            ?    最小空闲连接数:数据库连接池最少得未使用的数据库连接的数量
            
                最大空闲连接数:数据库连接池最大闲置连接数,当闲置连接数满了以后,将不会有其他连接进入池
            
            ?    每次增加连接数:当数据库连接都被占用以后,一次性增加的数据库连接的个数

            ?    最大连接数:数据库连接池的最大容量,当最大连接数饱和了,则不再创建新的数据库连接
            
            ?    最大等待时间:当数据库连接池饱和以后,等待获取数据库连接的时间
            
        > 常见的数据库连接池
            - 所有的数据库连接池都需要实现DataSource,当使用数据库连接池是,我们便不再需要使用DriverManger获取数据库连接
                而是使用DataSource。
                 - Connection getConnection()
                    - 从数据库连接池中获取数据库连接对象

            1.DBCP
                - DBCP是Apache出品的一款数据库连接
                - DBCP依赖于commons-pool
                - 使用DBCP需要导入两个jar包:
                    commons-dbcp-1.4.jar
                    commons-pool-1.5.5.jar
                - 当我们通过数据库连接池获取数据库连接以后,我们所获取到数据库连接已经不是我们熟悉的那个Connection
                    数据库连接池对Connection对象进行了包装,它修改Connection的close()方法,
                        再去调用close()数据库连接将不会真的关闭,而是要放回到数据库连接池中,供其他线程使用。
                - 核心类:
                    BasicDataSourceFactory
            
            
            2.C3P0(重点)
                - C3P0使用的是XML作为配置文件
                - 使用c3p0需要导入一个jar包:
                    c3p0-0.9.1.2.jar
                - 导入c3p0的配置文件:
                    1.配置文件的名字:c3p0-cofig.xml
                    2.配置文件要求放到类路径下(src)
                - 核心类:    
                    ComboPooledDataSource
                - 注意:
                    DataSource就相当于池子,我们的数据库连接都是从DataSource中获取的,
                        如果程序中有多个DataSource的实例,那么我们说你还不如不用数据库连接池。
                    所以我们的DataSource在项目中应该只有一个实例。


                    
                
实验23:引用外部属性文件★
       jdbc.properties文件:
        jdbc.user=root
        jdbc.passowrd=123456
        jdbc.url=jdbc:mysql://localhost:3306/test
        jdbc.driver=com.mysql.jdbc.Driver
        
    <context:property-placeholder location="classpath:jdbc.properties"/>
    1.在目标属性上加@Value注解
        @Value("${jdbc.user}")
        private String username;
    2.    
        <!-- 根据外部属性文件中的信息配置数据源 -->
        <bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.passowrd}"></property>
            <property name="jdbcUrl" value="${jdbc.url}"></property>
            <property name="driverClass" value="${jdbc.driver}"></property>
        </bean>
        
        
        ComboPooledDataSource bean = ioc.getBean(ComboPooledDataSource.class);
        Connection connection = bean.getConnection();
        System.out.println(connection);
        Statement st = connection.createStatement();
        ResultSet rs = st.executeQuery("select * from stu");
        while(rs.next()){
            String string = rs.getString("name");
            String string2 = rs.getString("school");
            System.out.println(string+"==="+string2);
        }
        

实验24:基于XML的属性装配
    ①手动装配
        <!-- 属性的装配:手动装配 -->
        <bean id="userService" class="com.neuedu.spring.bean.UserService"></bean>
        <bean  id="userAction" class="com.neuedu.spring.bean.UserAction">
            <property name="userService" ref="userService"></property>
        </bean>
        
    ②自动装配
        <!-- 1.按类型装配:byType -->
            <!-- 首先检测当前bean中需要装配的属性的类型 -->
            <!-- 然后在IOC容器中查找匹配这个类型的bean -->
            <!-- 如果类型匹配的bean是唯一的,那么就将这个匹配的bean注入到userAction中 -->
                
                <bean id="userService" class="com.neuedu.spring.bean.UserService"></bean>
                <bean  id="userAction" autowire="byType" class="com.neuedu.spring.bean.UserAction"></bean>
    
        <!-- 2.按bean的id值装配:byName -->
            <!-- 首先检测当前bean中需要装配的属性的属性名,属性名是将setXxx()方法去掉set,首字母小写得到的 -->
            <!-- 然后根据属性名作为id的值,在IOC容器中查找对应的bean -->
            <!-- 如果能够找到,则将找到bean注入进去 -->
        
        
        
6。SpEL简介【见WORLD文档---了解】
    Spring Expression Language,Spring表达式语言,简称SpEL。支持运行时查询并可以操作对象图。
    和JSP页面上的EL表达式、Struts2中用到的OGNL表达式一样,SpEL根据JavaBean风格的getXxx()、setXxx()方法定义的属性访问对象图,完全符合我们熟悉的操作习惯。
    
    6.1    基本语法
        SpEL使用#{…}作为定界符,所有在大框号中的字符都将被认为是SpEL表达式。
        
    6.2    使用字面量
        ●整数:<property name="count" value="#{5}"/>
        ●小数:<property name="frequency" value="#{89.7}"/>
        ●科学计数法:<property name="capacity" value="#{1e4}"/>
        ●String类型的字面量可以使用单引号或者双引号作为字符串的定界符号
            <property name=“name” value="#{'Chuck'}"/>
            <property name='name' value='#{"Chuck"}'/>
        ●Boolean:<property name="enabled" value="#{false}"/>

    
实验25:[SpEL测试I]在SpEL中使用字面量
实验26:[SpEL测试II]在SpEL中引用其他bean
实验27:[SpEL测试III]在SpEL中引用其他bean的某个属性值
实验28:[SpEL测试IV]在SpEL中调用非静态方法
实验29:[SpEL测试V]在SpEL中调用静态方法
实验30:[SpEL测试VI]在SpEL中使用运算符

8.使用注解配置bean
    ①声明bean的注解
        @Component 将当前类声明为IOC容器中的一个普通的组件
        @Controller 将当前类声明为IOC容器中的一个控制器组件
        @Service 将当前类声明为IOC容器中的业务逻辑层组件
        @Repository 将当前类声明为IOC容器中的一个持久化层组件
    Spring根据上述注解其实并不能分辨当前类是否真的是一个控制器或Dao,即使标记的类和注解不对应也没有语法错误。但在实际工作中,肯定要将专门的注解标记在对应的类上面。
    
    ②使用基于注解的bean的配置,需要额外导入一个jar包:spring-aop-4.0.0.RELEASE.jar
    ③需要设置自动扫描的包
        < context:component-scan base-package ="com.neuedu.ioc.bean"/>

        
    ④使用注解后,默认按照类名首字母小写作为id的值,也可以使用value属性指定id,value属性名也可以省略注解        
        注解                                           id值
    
        @Component                                    commonComponent
        public class CommonComponent {
        }
   
       @Controller(value="neueduBookAction" )         neueduBookAction
        public class BookAction {

        }
        
        @Service("happyService" )                     happyService
        public class BookService {

        }
    
    
实验31:通过注解分别创建Dao、Service、Controller★    
    
实验32:使用context:include-filter指定扫描包时要包含的类
实验33:使用context:exclude-filter指定扫描包时不包含的类

< context:component-scan base-package ="com.neuedu.ioc.bean"/>    
    [1]base-package属性指定一个需要扫描的基类包,Spring容器将会扫描这个基类包及其子包中的所有类。
    [2]当需要扫描多个包时可以使用逗号分隔,
    [3]如果仅希望扫描特定的类而非基包下的所有类,可使用resource-pattern属性过滤特定的类,示例:
        <context:component-scan base-package="com.neuedu.component" resource-pattern="autowire/*.class"/>
    [4]包含与排除
        ●<context:include-filter>子节点表示要包含的目标类
            注意:通常需要与use-default-filters属性配合使用才能够达到“仅包含某些组件”这样的效果。
            即:通过将use-default-filters属性设置为false,禁用默认过滤器,然后扫描的就只是include-filter中的规则
            指定的组件了。
        ●<context:exclude-filter>子节点表示要排除在外的目标类
        ●component-scan下可以拥有若干个include-filter和exclude-filter子节


        
⑤使用注解进行自动装配:@Autowired注解[好处就是:连get、set方法都不用写!]
    [1]首先检测标记了@Autowired注解的属性的类型
    [2]根据类型进行装配
    [3]如果指定类型的bean不止一个,那么根据需要被装配的属性的属性名做id的值,查找bean
    [4]如果根据id值还是没有找到bean,可以使用@Qualifier注解手动指定要装配的bean的id.
    
实验34:使用@Autowired注解实现根据类型实现自动装配★
实验34[补充1]:如果资源类型的bean不止一个,默认根据@Autowired注解标记的成员变量名作为id查找bean,进行装配★
实验34[补充2]:如果根据成员变量名作为id还是找不到bean,可以使用@Qualifier注解明确指定目标bean的id★
实验36:Autowired注解的required属性指定某个属性允许不被设置.
实验37:在类上使用注解@Scope可以指定对象是单实例还是多实例的!