spring的控制反转和依赖的注入

1.什么叫做spring？

spring也是一种开源的框架，
目的：是为了解决企业的应用开发的复杂性而创建的
应用的范围：是所有的java的应用的程序。
总之：spring是一个容器的框架，解决的是业务逻辑层与其他的层的耦合，将面向接口的编程的思想贯穿始终
用途：（1）整合其他的框架，让它们协同的工作
（2）提供了声明式的事务的管理（注解，或者xml的管理的文件）

2.控制反转的思想（IOC inversion of controller）

控制反转的思想：就是将控制对象的生命周期的权利交给第三方的（spring）管理 不用自己每次去new 一个对象 然后将新建的对象工作去交给框架去完成
举例：servlet的产生是利用tomcat的容器来产生的
spring容器可以创建的对象的类型更加的丰富
通俗的说就是将新建的所有的对象都登记在一个spring的容器的里面，你会告诉spring的容器你是一个什么东西，你需要什么东西，当spring的容器运行到适当的时候，会将你需要的东西来提供给你，也会将把你提供给其他的需要你的东西，spring容器来控制一个对象的创建和销毁，以前的话是引用的对象来进行控制其他的对象，现在的话所有的对象呗spring的容器所控制，这个叫做控制的反转

3.spring容器的使用

(1)在pom.xml 文件里面添加依赖

<properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>
<dependencies>
    <!--spring的相关的jar包-->
    <dependency>
        <groupId>com.baidu</groupId>
        <artifactId>spring-maybatis</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>

    <!--日志的jar包-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
    <!--mybatis的jar包-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    <!--mybatis与spring的结合-->
    <dependency>
        <groupId>com.baidu</groupId>
        <artifactId>spring-maybatis</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--用来管理jdbc的jar包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.3.17.RELEASE</version>
    </dependency>
    <!--连接数据库的jar包-->
   <dependency>

        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.12</version>
    </dependency>
    <!--德鲁伊的连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.7</version>
    </dependency>
</dependencies>

（2）在resources的文件夹里面编写spring的xml的文件，定义自己要控制反转的类，id在这里是唯一的表示，利用bean的 标签来将管理spring的容器的类

<?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">
<bean id="userDao" class="com.www.dao.UserDao" >
    </bean>
 </beans>

（3）使用spring的容器来创建对象
第一步：新建一个ClasspathxmlApplication的对象，参数填写的是文件的位置（以java，resources为起点）
第二步：使用ClasspathxmlApplication的getBean的方法获取对象
有两种的获取的方式：
1：id值 UserDao userDao = (UserDao) context.getBean(“userDao”);
2：类.class UserDao userDao = context.getBean(UserDao.class);

ClassPathXmlApplicationContext  context 
                = new ClassPathXmlApplicationContext("spring/spring.xml");

public class UserDao {
    private User user;

    public User getUser(){
        return this.user;
    }
    public void delete(){
        System.out.println("userDao的删除的方法");
    }

    public void setUser(User user) {
        this.user = user;
    }
}

注意事项：
1：id的值是唯一的，入如果获取的id的值是不存在的话，出现一个异常：NoSuchBeanDefinitionException
2：bean一般的使用的是无参的构造的方法，但是如果要是控制反转的类是没有无参构造的话，需要将手动利用赋值：
对应的是set的方法
对应的是构造的方法 index对应的是参数的位置（默认第一个参数的位置是0开始的）
3：如何来控制spring容器中的对象的个数：在默认的情况下的个数是一个，但是要设置为多个的话，可以使用的scope=“prototype” 来实现多个对象的创建
4：初始化和销毁的方法：在单例模式的情况之下初始化和销毁的方法都会被调用的，在执行多个模式的情况之下的话，只会执行的是初始化的方法

4.依赖注入

什么叫依赖的注入？
依赖注入就是：就是给bean的属性赋值的过程。（利用了反射的机制）
依赖的注入一共有三种的方式：
（1）：第一种的方式：
set方法的注入：

<bean id="userService" class="com.www.service.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>

对应的是set的方法 ref对应的是bean的对象的id
（2）：第二种的方式：
构造的方法的注入：

<bean id="userService" class="com.baidu.service.UserService">
        <constructor-arg index="0" ref="userDao"/>
    </bean>

（3）：第三种的方法：
注解的方式进行注入：
利用@Resource("")进行依赖的注入 是java自带的注解

@Resource
   private UserDao userDao;

利用@Autowired的方式进行注入 注入的类型可以为接口，注入的属性为普通的属性的话，利用@Value的属性

 @Autowired
    private UserDao userDao;

*.properties的注入

属性赋值的时候如果出现中文乱码的问题的话，添加一个file-encoding=“UTF-8”

<context:property-placeholder location="classpath:h.properties" file-encoding="UTF-8"/>
    <bean id="user" class="com.www.entity.User">
 
     <property name="password"  value="${h.password}"/>
     <property name="username"  value="${h.username}"/>
    </bean>

与可以通过@value的注释来进行对属性的赋值

 @Value("${h.username}")
    private String username;
    @Value("${h.password}")
    private String password;

spring与mybatis的整合

（1）pom.xml的文件中加入应有的依赖
（2）将该有的对象进行spring的控制的反转
（3）使用sqlsession进行增删改查的操作
举例：
相关的主要得代码：

<?xml version="1.0" encoding="UTF-8" ?>
<!--xmlns在这里设置的是命名的空间-->
<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" xmlns:util="http://www.springframework.org/schema/util"
       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 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <!--配置连接池，将数据源的对象交给spring的容器-->
    <context:annotation-config/>
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <!--对数据源的参数进行配置-->
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="maxActive" value="${jdbc.max}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="minIdle" value="${jdbc.min}"/>
    </bean>
    <!--sqlSessionFactory的创建-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入连接池-->
        <property name="dataSource" ref="dataSource"/>
        <!--注入匹配的的文件-->
        <property name="mapperLocations" value="classpath:com/www/mapper/UserMapper.xml"/>
    </bean>
    <!--sqlSession的创建  SqlSessionTemplate可以帮助我们管理事务，资源的关闭-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
</beans>

UserMapper.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="com.www.mapper.UserMapper">
    <select id="select" parameterType="map" resultType="com.www.entity.User">
        select * from user limit #{start},#{num}
    </select>
</mapper>

有关的java的代码

 static ClassPathXmlApplicationContext  context =
            new ClassPathXmlApplicationContext("spring/spring-mybatis.xml");

    @Test
    public void select() throws SQLException {
        SqlSession sqlSession = context.getBean(SqlSession.class);
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("start",0);
        map.put("num",3);
        List<Object> list = sqlSession.selectList("com.www.mapper.UserMapper.select", map);
        for (Object o : list) {
            System.out.println(o);
        }