14、spring-IOC

Spring：

依赖：类a中使用类b中的属性或者方法，叫作类a依赖类b

官网：

https://spring.io/

IOC控制反转：

控制反转的概念：

容器：是一个服务器软件，一个框架（spring）

为什么要使用IOC：减少对代码的改动，也能实现不同的功能。实现解耦合

IOC的体现：

IOC的技术实现：

使用Spring容器创建对象：

导入依赖：

统一版本：

5.2.12.RELEASE 
1

    
      org.springframework
      spring-webmvc
      ${spring.version}
    
    
      org.springframework
      spring-core
      ${spring.version}
    
    
    
      org.aspectj
      aspectjweaver
      1.9.4
    
    
    
      org.springframework
      spring-jdbc
      ${spring.version}
    

    
    
      org.mybatis
      mybatis-spring
      2.0.5
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1、创建配置文件

<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="foreuser" class="com.cykj.entity.Foreuser">bean>
beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2、测试方法：

/**
     * 使用Spring容器创建对象
     *默认调用的是无参构造方法
     */
    @Test
    public void springTest(){
        //1、指定Spring配置文件的路径
        String config = "applicationContext.xml";
        //2、创建Spring容器对象，ApplicationContext
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //3、从容器中获取对象
        Foreuser foreuser = (Foreuser) ac.getBean("foreuser");
        System.out.println(foreuser);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Spring创建对象的时间：在创建容器时创建配置文件中的所有对象

获取Spring容器中Java对象的信息：

/**
     * 获取Spring容器中Java对象的信息
     */
    @Test
    public void springTest2(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //获取容器中定义的对象的数量
        int nums = ac.getBeanDefinitionCount();
        System.out.println("容器中定义的对象的数量："+nums);
        //容器中每个定义的对象的名称
        String[] names = ac.getBeanDefinitionNames();
        for(String name:names){
            System.out.println(name);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

依赖注入：

实现方式：

1、xml方式注入

2、注解方式注入

语法分类：

1、设值注入（set）：常用

2、构造注入

简单类型的设值注入：

 <!--声明foreuser对象
    注入：就是赋值的意思
    简单类型的注入：Spring中规定Java的基本数据类型和String类型都是简单类型
        1、简单类型的注入：
            <bean id="xx" class="yy">
                <property name="属性名称" value="属性值">
                一个property只能给一个属性赋值
                <property.....>
            </bean>
    -->
    <bean id="foreuser" class="com.cykj.entity.Foreuser">
        <property name="fuId" value="1"></property><!--调用的是setFuId()方法-->
        <property name="fuName" value="张三"></property>
    </bean>

/**
     * 简单类型的注入
     */
    @Test
    public void springTest3(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Foreuser foreuser = (Foreuser) ac.getBean("foreuser");
        System.out.println(foreuser);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

引用类型的设值注入

<!--
        2、引用类型的注入：
            <bean id="xx" class="yy">
                <property name="属性名称" ref="bean的id（对象的名称）">
            </bean>
    -->
    <bean id="tblUser" class="com.cykj.entity.Tbluser">
        <property name="userId" value="1"></property>
        <!--引用类型-->
        <property name="tblrole" ref="tblRole"></property>
    </bean>
    <bean id="tblRole" class="com.cykj.entity.Tblrole">
        <property name="roleId" value="1"></property>
        <property name="roleName" value="管理员"></property>
    </bean>


/**
     * 引用类型的注入
     */
    @Test
    public void springTest4(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Tbluser tbluser = (Tbluser) ac.getBean("tblUser");
        System.out.println(tbluser);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

构造器注入：

引用类型的自动注入：

byName，byType

注解：

<!--统一管理bean
声明组件扫描器，组件就是Java对象
base-package:要扫描的包
component-scan工作方式：Spring会扫描遍历base-package指定的包
    把包中的所有类，找到类中的注解，按照注解的功能来创建对象，或给属性赋值
-->
<context:component-scan base-package="com.cykj"/>
1
2
3
4
5
6
7

@Component

@Service

@Respository

简单类型的属性赋值：@value

引用类型的属性赋值：@AutoWrite（bytype）

整合mybatis

1、使用IDEA创建maven工程

2、在pom中引入所有的依赖

3、在main文件夹下创建文件夹java以及resources，并通过项目结构功能将java及resources分别标记为对应功能

4、在resources文件夹中创建mapper文件夹，用来存放mybatis中所有mapper的xml文件

5、在resources创建mybatis配置文件：mybatis-config.xml

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
    settings>
    
    <typeAliases>
        <package name="com.cykj.bean"/>
    typeAliases>
    <mappers>
        <mapper resource="mapper/UserMapper.xml">mapper>
    mappers>
configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

六、在resources创建spring的配置文件，并整合mybatis框架：applicationContext.xml

<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/context
         https://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">
    

    
    <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/train12306-2?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    bean>
    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    bean>
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">property>
        <property name="basePackage" value="com.cykj.mapper">property>
    bean>


    
    <context:component-scan base-package="com.cykj"/>
beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

七、修改web.xml文件，配置spring核心文件

DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Applicationdisplay-name>

  <context-param>
    
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
  context-param>
  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>
web-app>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

八、在java文件夹中分别创建servlet\service\mapper\bean文件夹

九、编写测试的所有代码，测试spring与mybatis是否可用

十、Servlet中本来不能使用@Autowired注入bean，解决办法修改每个servlet中的init方法

package com.cykj.web;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

public class BaseServlet extends HttpServlet {
    private ApplicationContext app;

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        //Servlet中本来不能使用@Autowired注入bean，解决办法是在Servlet的init（ServletConfig）方法中调用
        SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this, config.getServletContext());
        app = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    }
    public Object getObject(Class c) {
        return app.getBean(c);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

nfig config) throws ServletException {
super.init(config);
//Servlet中本来不能使用@Autowired注入bean，解决办法是在Servlet的init（ServletConfig）方法中调用
SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this, config.getServletContext());
app = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
}
public Object getObject(Class c) {
return app.getBean©;
}
}

1
2
3
4
5