今天完成的事情：

一、回顾下spring的基础知识。

1.spring的框架包括很多的内容，我目前学习的就是使用IOC容器进行对象的管理。案例采用idea基于maven建项目，加入spring的依赖包。spring相关的依赖包有很多，为了避免各个jar包之间版本的兼容关系，这里pom.xml配置文件里加入properties标签，加入子标签

<spring.version>4.1.1.RELEASE</spring.version>

之后的依赖包<version>标签如下表示，采用spring的版本

<version>${spring.version}</version>

2.spring的核心配置文件中把所有的对象称之为bean，通过配置bean来完成各种对象的声明，这样在程序中若需要创建某个对象，只需要调用在配置文件中定义的bean即可，这样就实现了对象的统一管理。

3.从最基本的开始，通过bean实现类来对接口的实例化，从而调用接口的方法

（1）首先定义接口userdao，简单起见，方法只打印输出一句话，接口

package com.lihq.spring.dao;
public interface UserDao {
    void save();
}

（2）接口实现类：

package com.lihq.spring.impl;
        import com.lihq.spring.dao.UserDao;
public class UserDaoImpl implements UserDao{
    public void save(){
        System.out.println("我会唱歌....");
    }
}

（3）这种情况下，xml的配置文件里只需要定义UserDaoImpl这个实现类

<!--简单的依赖注入，bean属性id是名字，唯一不可重复，class是具体的包名加类名，这个class类继承了需要的接口ueerDao,
    实现了其中的方法，可以这么理解，这个类被加载到IOC容器当中，-->
<bean id="userDaoImpl" class = "com.lihq.spring.impl.UserDaoImpl"/>

（4）写一个简单的测试：

public class UserDaoImplTest {
    @Test
    /**
     * 简单测试的bean的依赖注入
     */
    public void save() throws Exception {
       ApplicationContext ctx=new ClassPathXmlApplicationContext("springConfig.xml");
        UserDao userDao= (UserDaoImpl) ctx.getBean("userDaoImpl");
        userDao.save();

（5）测试结果

（6）从结果可以看出，UseDao这个接口的方法已经可以正常使用了。换位思考一下，如果需要在UserDao这个接口的方法中需要新增一个方法a,那么只需要重新写一个实现类并在xml文件中定义bean标签即可。

4.（1）第3小点中定义的实现类比较简单，并没有属性，下面写个稍微复杂一点的类包括属性和方法。

package com.lihq.spring.entity;
import com.lihq.spring.dao.UserDao;
import java.util.List;
import java.util.Map;

/**
 * 典型的学生类，包括id，姓名，爱好，分数
 */
public class User {
    //定义一些成员变量，user的属性,包括基本数据类型和引用数据类型
    private int id;
    private String name;
    private UserDao userDao;//引用数据类型
    private List<String> hobbies;//集合数据类型
    private Map<String,Integer> scores;
    //构造方法包含所有的参数
    public User(int id,String name,UserDao userDao,List hobbies,Map scores){
        this.id=id;
        this.name=name;
        this.userDao=userDao;
        this.hobbies=hobbies;
        this.scores=scores;
    }
    //无参构造法，在使用构造方法注入的时候必须有无参构造也就是默认的构造方法
    public User(){

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, Integer> getScores() {
        return scores;
    }

    public void setScores(Map<String, Integer> scores) {
        this.scores = scores;
    }
}

（2）上面定义了一个实体类user，成员变量包括基本数据类型，集合类还有引用数据类型， 下面通过bean 注入方式的设值注入方式。

<!--set方法,包括基本类型数据，复杂类型，list和map，还有引用类型其它bean//userDaoImpl-->
<bean id="user" class="com.lihq.spring.entity.User">
    <property name="id" value="1"/>
    <property name="name" value="张三"/>
    <property name="userDao" ref="userDaoImpl"/>
    <property name="hobbies">
        <list>
            <value>羽毛球</value>
            <value>电影</value>
            <value>弹吉他</value>
        </list>
    </property>
    <property name="scores">
        <map>
            <entry key="数据结构" value="90"/>
            <entry key="编译原理" value="89"/>
            <entry key="算法分析" value="99"/>
        </map>
    </property>
</bean>

（3）这种设值的注入方式，直接在xml的bean标签中定义子标签，对成员变量逐一赋值的方式来完成对象的初始化操作。需要注意的一点的就是对于基本数据类型的数据，在子标签的属性名用的是value,引用数据类型属性名用的ref，并且它的值“”在xml文件里需要定一的bean的id。

（4）简单写个测试类

public void userTest(){
    ApplicationContext ctx=new ClassPathXmlApplicationContext("springConfig.xml");
    User user= (User) ctx.getBean("user");
    UserDaoImplTest.printUser(user);
}
//写一静态方法来输出user的信息
public static void printUser(User user){
    System.out.println("编号："+user.getId());
    System.out.println("姓名："+user.getName());
    System.out.println("爱好：");
    for(String sb:user.getHobbies()){
        System.out.println(sb);
    }
    System.out.println("学习成绩：");
    for(Map.Entry<String,Integer> entry:user.getScores().entrySet()){
        System.out.println(entry.getKey()+"\t"+entry.getValue());
    }
    user.getUserDao().save();
}

（5）输出结果

（6）分析下，这种注入方式是最直观也是最容易理解的，但是如果说某个的引用类型的成员变量有很多，那么在xml中配置起来就很麻烦，这个时候就需要用注解的方式来完成bean注入

（7）另外跟设置注入相似的还有一中叫做构造方法注入，其实本质是一样的，只不过构造注入时把这些属性写成一个构造方法，然后在通过属性的set方法来实现属性赋值。

5.下面重点写一下注解注入方式

（1）注解本质就是一组元数据，可以通过Java反射机制获取这些元数据，并传入需要的类，方法等等中，它的好处就是可以是的代码更简洁，最直观的体现就是xml文件中不需要逐个来配置bean了，spring这个框架提供了很丰富的注解，极大的减小了xml中配置工作。

（2）在使用注解之前需要在xml文件里配置下

<context:annotation-config/><!--这个配置就是要Ioc注册注解，使注解可以起作用-->
<!--自动加载对象-->
<context:component-scan base-package="com.lihq.spring.entity"/>

（3）新建一个user2

package com.lihq.spring.entity;
import com.lihq.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import javax.annotation.Resource;

public class User2 {
    private int id;
    private String name;
    @Resource(name="userDaoImpl")
    private UserDao userDao1;

    private UserDao userDao2;

    @Autowired(required = false)
    @Qualifier("userDaoImpl")
    private UserDao userDao3;

    @Autowired(required = false)
    @Qualifier("userDaoImpl")
    private UserDao userDao4;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public UserDao getUserDao2() {
        return userDao2;
    }
    @Resource
    public void setUserDao2(UserDao userDao2) {
        this.userDao2 = userDao2;
    }

    public void test(){
        userDao1.save();
        userDao2.save();
        System.out.println(userDao3.getClass().getName());
        userDao3.save();
    }

}

（4）写一个test类

public class User2Test {
    @Test
    public void test1() throws Exception {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("springConfig.xml");
        User2 user2= (User2) ctx.getBean("user2");
        System.out.println(user2);
        user2.test();
    }

（5）测试结果

（6）通过注解注入的方式，在引用类或者接口的属性上加入注解，那么spring的注解处理器就可以直接将其加入到IOC容器中，需要的时候直接调用即可。

明天的计划：

1.继续学习springMVC

遇到的问题：

无

总结：

1.总结已经写到每个小例子结果分析里。