今天完成的事情：

1.因为xml配置bean总是有问题，所以又看了一遍依赖注入和控制反转的概念

（方法过时不让用，‘Mapperinterface’属性也报红不能用，用MapperScannerConfigurer自动扫描注入）

2.重写了spring-mybatis，整合完成（昨天写的有问题，虽然可以查询，但是其它的方法完全不能用），加入了c3p0连接池。

3.测试使用@Test注解，@RunWith测试运行器，使用@ContextConfiguration注入xml配置。不知道为什么new UserMapper报红线，但是可以运行。

1.关于依赖注入和控制反转的概念：

又看了一遍依赖注入和控制反转的概念，跟之前认识的有些差距：

依赖注入就是对象依赖IOC容器去获取资源；

控制反转和依赖注入是一个概念，但是角度不同，所以思考方向也就不一样。

打个比方来说：

一个程序运行需要外部资源。比如一个classA里面要使用resourceC（当然这个C也可以是Class等），一般来说是A用的时候去直接调用C，就是在A里直接创建C的对象。而依赖注入和控制反转就不一样了。依赖注入就是A不再去主动调用C，而是等待IOC容器去获取C的实例，然后注入A之中。就是由主动变为被动。这个从A的角度说就是A依赖IOC创建C并注入（依赖注入）。从IOC容器的角度来说就是拿到C反向注入到A中（控制反转）。

依赖注入的三种方式：

）构造方法注入：“即被注入对象可以通过在其构造方法中声明依赖对象的参数列表，让外部（通常是IOC容器）知道它需要哪些依赖对象，然后IOC容器会检查被注入对象的构造方法，取得其所需要的依赖对象列表，进而为其注入相应对象。”

）Setter方法注入：“即被注入对象可以通过在其构造方法中声明依赖对象的参数列表，让外部（通常是IOC容器）知道它需要哪些依赖对象，然后IOC容器会检查被注入对象的构造方法，取得其所需要的依赖对象列表，进而为其注入相应对象。”

）接口注入：“接口注入有点复杂，被注入对象如果想要IOC容器为其注入依赖对象，就必须实现某个接口，这个接口提供一个方法，用来为被注入对象注入依赖对象，IOC容器通过接口方法将依赖对象注入到被注入对象中去。相对于前两种注入方式，接口注入比繁琐和死板，被注入对象就必须专声明和实现另外的接口。”

看了Spring实战，正好看到相关的问题。因为接口方式注入耦合度很高，不利于单元测试与重构，而且还会让内部方法做一些额外的超出自己能力的事，所以基本上不用。而setter和构造器不仅耦合低，而且利于使用，单元测试也能写的很方便。

在代码上两者的区别就是配置的方式不一样：

constructor-arg配置是通过构造函数注入。 
property配置name/value值是通过setter对应的方法注入。

同样的，构造方法和setter在类里的写法也不一样，但是都用到this：

构造方法是直接在构造方法里写：

public class A implements B{    

     private C  c; 

setter是使用set方法：

public class Aimplements B{    

     private C c; 

这两者的区别：

构造方法是必须要有的，可以不写，不写的时候系统会自动创建一个无参的构造方法。构造方法的作用也是对成员变量进行初始化，是声明这个类型变量的时候给的初始值，类似new然后用“=”赋值。如果写了有参的构造方法系统就不会自动生成无参的构造方法，所以也需要写一个无参的构造方法。当然写了构造方法注入就不用再写set注入方法了。

set方法可以多个属性每个都有set方法，如果有很多依赖需要注入的话使用构造方法里的属性也会很多，而且如果属性参数类型相同的话也不方便使用。构造函数因为初始化就已经赋值了，如果需要改变里面的变量就需要用到set方法，如果需要获取private的属性就需要get方法。

2.新建项目，配置连接池，使用mybatis+spring创建，完成增删改查的操作。

目录：

pom.xml:

<dependencies>

  <!--junit-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
  </dependency>

  <!--数据库连接池 c3p0-->
  <dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
  </dependency>

  <!--mysql包-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.40</version>
  </dependency>

  <!--mybatis包-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
  </dependency>

  <!--mybati-spring包-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
  </dependency>

  <!--spring jar包-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-orm</artifactId>
  <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-oxm</artifactId>
    <version>5.0.4.RELEASE</version>
  </dependency>

  <!--slf4j日志包-->
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.12</version>
  </dependency>

  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.16</version>
  </dependency>

  <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
  </dependency>

</dependencies>

Spring配置文件ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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/beans
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <!-- dataSource 连接池 c3p0-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="user">
            <value>root</value>
        </property>
        <property name="password">
            <value>root</value>
        </property>
        <property name="jdbcUrl">
            <value>jdbc:mysql://localhost:3306/jnshu</value>
        </property>

        <!--连接池中保留的最大连接数。Default: 15 -->
        <property name="maxPoolSize">
            <value>30</value>
        </property>

        <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
        <property name="initialPoolSize">
            <value>5</value>
        </property>

        <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
        <property name="maxIdleTime">
            <value>60</value>
        </property>

        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
        <property name="acquireIncrement">
            <value>5</value>
        </property>

    </bean>

    <!--创建bean    会话工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/> <!--数据源-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/><!--mapper配置文件-->
    </bean>

    <!-- 通过扫描的模式注册接口类的bean，扫描目录下的所有的java类-->
    <!--MapperScannerConfigurer会创建MapperFactoryBean之后自动装配-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="springmybatis.mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!--事务管理器-->
    <bean id="transactionManager"   class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

配置的主要一个是数据源，一个是创建session工厂，把需要的mapper注册bean

然后是mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC  "-//mybatis.org//DTD mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="springmybatis.mapper.UserMapper">
    <resultMap id="userMap" type="springmybatis.model.User" >
        <id column="id" property="id"/>
        <result column="create_at"  property="create_at"/>
        <result column="update_at"  property="update_at"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
        <result column="sex"  property="sex"/>
        <result column="pro" property="pro"/>
        <result column="brother"  property="brother"/>
    </resultMap>

    <!--命名sql语句 可以在下面调用 这里没用到-->
    <sql id="jnshu_user_column">
        id,create_at,update_at,name,age,sex,pro,brother
    </sql>
    <!-- 要么是resultMap="userMap"   要么是resultTpye="int" -->
    <select id="selectById" parameterType="int" resultMap="userMap" >
        SELECT        * FROM jnshu_user WHERE id = #{id}
    </select>
    <select id="findAllUser" parameterType="springmybatis.model.User" resultMap="userMap">
        SELECT * FROM jnshu_user
    </select>

    <insert id="insertUser" parameterType="springmybatis.model.User" useGeneratedKeys="true"  keyProperty="id" >
        INSERT INTO jnshu_user(id,create_at,update_at,name,age,sex,pro,brother) values (#{id},#{create_at},#{update_at},#{name},#{age},#{sex},#{pro},#{brother})
    </insert>

    <update id="updateUser" parameterType="springmybatis.model.User" >
        Update jnshu_user SET name=#{name},age=#{age},sex=#{sex},pro=#{pro},brother=#{brother} WHERE id=#{id}
    </update>
    
    <delete id="delectUser" parameterType="int"  >
        DELETE FROM jnshu_user WHERE id = #{id}
    </delete>

</mapper>

namespace比较容易出错，还有resultMap和resultType，resultMap是包含resultType的

UserMapper: 方法跟xml里的id要对应上

public interface UserMapper {

        public User selectById(int id);
        List<User> findAllUser();
        void insertUser(User user);
        void updateUser(User user);
        void delectUser(int id);

}

3.junit注解测试

import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import springmybatis.mapper.UserMapper;
import springmybatis.model.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
public class Test {

    @Autowired
    UserMapper userMapper;

    @org.junit.Test
    public void testSlectById(){

        System.out.print(userMapper.selectById(4));
    }

    @org.junit.Test
    public void testInsert(){

        User user = new User();
        //        user.setId(5);
        user.setName("胡海权");
        user.setAge(20);
        user.setCreate_at(20120301);
        user.setUpdate_at(20130927);
        user.setSex(1);
        user.setPro("我让你飞！");
        user.setBrother("风之子");

        userMapper.insertUser(user);
    }

    @org.junit.Test
    public void testdelect(){

        userMapper.delectUser(28);
    }

    @org.junit.Test
    public void testUpdate(){
        User user = new User();
        user.setId(29);
        user.setName("李苍天");
        user.setAge(33);
        user.setCreate_at(20111108);
        user.setUpdate_at(20120322);
        user.setSex(1);
        user.setPro("你们都在我眼皮底下");
        user.setBrother("拉布拉多");
        userMapper.updateUser(user);

    }

    @org.junit.Test
    public void testFindAllUser(){

        System.out.print(userMapper.findAllUser());

    }

}

测试结果：

明天计划的事情：

·使用github上传代码

·一边加深前面的印象一边开始跟线上/远程服务器打交道

·Spring框架

遇到的问题：

还是xml的配置，熟悉了就没什么问题。

注解开发，还有不知道开发的规范。

收获：

·spring-mybatis可以明白的成功跑通了

·对于依赖注入和控制反转有清晰的印象

·数据池有概念了（控制连接数量，保证数据库负荷，对接入访问连接进行控制，回收空闲连接，把控资源）

·可以使用注解测试：

@ContextConfiguration(locations = {"classpath*:applicationContext.xml"})