Spring使用applicationContext管理bean

今天药忘吃喽~ 2021-08-29 01:11 436阅读 0赞

## Spring使用applicationContext管理bean ##

Spring是Java EE编程领域的一个轻量级开源框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架 。Spring的两个核心就是IoC控制反转和AOP面向切面编程。

### 1、看需求 ###

设计三张表：部门表、用户表、角色表，表中字段自拟，基于MyBatis的设计以下业务操作：
    1. 根据用户名和密码查询用户
    2. 新增用户、部门、角色
    3. 为用户分配部门、角色查询角色
    4. 查询指定部门的角色
    5. 查询指定角色的用户

我们至少需要3张表，但是为了方便连接查询，所以我们还需要两张中间表，所以我们一共需要5张表，分别是用户表user、角色表role、部门表dept、user\_role表和role\_dept表

### 2、建表 ###

user表：

![在这里插入图片描述][20200508112831772.png]

role表：

![在这里插入图片描述][20200508112855412.png]

dept表：

![在这里插入图片描述][20200508112905510.png]

user\_role表：

![在这里插入图片描述][20200508112917516.png]

role\_dept表：

![在这里插入图片描述][20200508112927175.png]

### 3、创建Maven项目 ###

依旧是创建Maven的quickstart骨架，[如何在eclipse和IDEA里创建Maven项目][eclipse_IDEA_Maven]

### 4、在src/main下新建resources资源文件夹，目的是存放application配置文件以及mybatis的相关配置文件 ###

### 5、在pom.xml里引入相关依赖 ###

因为我们需要用到Junit测试，所以需要Junit依赖；因为我们需要对数据库进行操作，需要MySQL驱动依赖；因为我们需要使用Mybatis进行CRUD，所以我们需要Mybatis依赖；以及mybatis-spring依赖，springframework框架的core、test、content、jdbc依赖，因为我们在连接数据源的时候需要用的阿里巴巴的druid连接池，所以我们还需要添加druid依赖

<dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.23</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>3.5.4</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>2.0.4</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-beans</artifactId>
          <version>5.0.8.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.10</version>
        </dependency>
      </dependencies>

写好之后，编译器就会自动从远程Maven仓库下载jar包，如果实现不知道你需要的依赖包的版本，也可以去Maven仓库官网搜索https://mvnrepository.com/

### 6、对应数据库的字段和数据的数据类型建立pojo类 ###

记得在类里生成它的无参，有参，toString、getter和setter方法

### 7、新建Mapper接口，完成需求 ###

看需求：

设计三张表：部门表、用户表、角色表，表中字段自拟，基于MyBatis的设计以下业务操作：
    user:
    1. 根据用户名和密码查询用户
    user、role、dept:
    2. 新增用户、部门、角色
    3. 为用户分配部门、角色查询角色
    dept:
    4. 查询指定部门的角色
    role:
    5. 查询指定角色的用户

RoleMapper.java:

public interface RoleMapper { 
        //查询指定角色的用户
        Role selectRoleAndUser(int role_id);
        //新增部门
        int insertRole(Role role);
    }

UserMapper和DeptMapper同理

### 8、在资源文件夹下创建Mapper.xml文件 ###

多表连接查询可以翻看我之前的笔记：https://blog.csdn.net/weixin\_45747080/article/details/105252194

RoleMapper.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="cn.wqk.mapper.RoleMapper">
        <select id="selectRoleAndUser" parameterType="integer" resultMap="RoleAndUserMap">
            SELECT
                u.user_name,r.role_id,r.role_name
            FROM
                sys_role r ,
                sys_user u ,
                sys_user_role ur
            WHERE
                r.role_id=#{role_id}
                AND ur.role_id=r.role_id
                AND u.user_id=ur.user_id
        </select>
        <resultMap id="RoleAndUserMap" type="Role">
            <id property="role_id" column="role_id"/>
            <result property="role_name" column="role_name"/>
            <collection property="userList" ofType="User">
                <result property="user_name" column="user_name"/>
            </collection>
        </resultMap>
        <insert id="insertRole" parameterType="Role" useGeneratedKeys="true" keyProperty="role_id">
            INSERT INTO
                sys_role
            (role_name,role_key)
            VALUES
            (#{role_name},#{role_key})
        </insert>
    </mapper>

因为我的sys\_role表里设置了role\_id字段自增，所以我就在insert标签里使用了useGeneratedKeys和

keyProperty属性来让表中字段自增。resultMap也是我们自己定制的SQL返回结果集，这里也体现了Mybatis的自定义SQL的特性。

而且我在自定义结果集里添加了collection属性，所以相应的，**我们也应该在pojo包的Role类里添加`List<User> userList`以及它的get和set方法才行**

### 9、创建Mapper接口的实现类 ###

在Spring里Mapper接口的实现类有三种方式，实质上就是获取SqlSession对象然后再接口回调调用对应的方法，在我之前的笔记有所提到：https://blog.csdn.net/weixin\_45747080/article/details/105851028第11点里有所提到，官网推荐的就是第三种，所以我们也用第三种：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc0NzA4MA_size_16_color_FFFFFF_t_70]

创建RoleMapper接口的实现类RoleMapperImpl需要继承SqlSessionDaoSupport，它内置了一个**getSqlSession方法可以直接获取SqlSession对象**

RoleMapperImpl.java:

public class RoleMapperImpl extends SqlSessionDaoSupport implements RoleMapper{ 
        @Override
        public Role selectRoleAndUser(int role_id) { 
            return getSqlSession().getMapper(RoleMapper.class).selectRoleAndUser(role_id);
        }
    
        @Override
        public int insertRole(Role role) { 
            return getSqlSession().getMapper(RoleMapper.class).insertRole(role);
        }
    }

### 10、db.properties数据库连接配置文件 ###

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/表名?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    jdbc.username=你的数据库连接用户名
    jdbc.password=你的数据库连接密码

### 11、在src/main/resources资源文件夹下创建mybatis-config.xml MyBatis配置文件 ###

因为我们需要用Spring来帮我们建立数据库并且获取SqlSession，所以我们就不再Mybatis的配置文件里再次配置数据源了

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <typeAliases>
            <package name="cn.wqk.pojo" />
        </typeAliases>
        
        <mappers>
            <mapper class="cn.wqk.mapper.UserMapper"/>
            <mapper class="cn.wqk.mapper.RoleMapper"/>
            <mapper class="cn.wqk.mapper.DeptMapper"/>
        </mappers>
    </configuration>

### 12、在src/main/resources资源文件夹下创建spring-dao.xml专注于获取SqlSession对象 ###

<?xml version="1.0" encoding="UTF-8"?>
    <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/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">
        
        <context:property-placeholder location="classpath:db.properties"/>
        
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
        </bean>
        
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <constructor-arg index="0" ref="sqlSessionFactory"/>
        </bean>
    </beans>

注意在第一步之前需要引入db.properties文件，也可以不用引入，然后自己写在value里，但是建议还是引入。第二部就需要引入Mybatis的配置文件，第三步就是获取sqlSesion对象

### 13、在src/main/resources资源文件夹下创建spring-service.xml专注于service ###

因为我们刚刚给RoleMapper的实现类中使用了SqlSessionDaoSupport里的getSqlSesion，所以我们就需要在spring-service里它注入sqlSessionFactory，这里也体现了Spring的依赖注入的特点。因为我们在测试或者业务的时候需要用的pojo类，我们就不再去new他们，而是直接用`@Autowired`自动装配他们，\*\*所以我们就需要在pojo包的几个类里添加`@Component`注解，同时还需要再spring-service.xml添加component-scan来扫描他们。\*\*关于注解的用法，在我之前的笔记里也有提到：https://blog.csdn.net/weixin\_45747080/article/details/105521415

### 14、最后把spring-service和spring-dao都丢到applicationContext容器里 ###

用import导入spring-service和spring-dao就行了

#### 其实上面这些spring-dao和spring-service都可以写在applicationContext一个文件里里，但是建议这样分开写，这样看起来分工明确，条理更加清晰。 ####

#### 所以Spring又被称为“配置地狱”，到了SpringBoot就会好很多。 ####

### 15、Junit测试 ###

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = { "/applicationContext.xml"})
    public class RoleMapperTest { 
        @Autowired
        RoleMapper roleMapper;
        @Autowired
        Role role;
        @Test
        public void selectRoleAndUser() { 
            Role role = roleMapper.selectRoleAndUser(7);
            System.out.println(role.getRole_name()+"有");
            for (User user : role.getUserList()) { 
                System.out.println(user.getUser_name());
            }
        }
    
        @Test
        public void insertRole() { 
            role.setRole_name("测试部门");
            int i = roleMapper.insertRole(role);
        }
    }

因为我们要用spring内置内置的test，所以就需要在头里面引入`@RunWith(SpringJUnit4ClassRunner.class)`和`@ContextConfiguration(locations = {"/applicationContext.xml"})`这里引入的是我们的spring容器的文件。因为我们把RoleMapper接口和pojo类都丢入了spring容器，所以我们直接用`@Autowired`进行自动装配他们就不需要在下面new他们了。而且我在mapper.xml里给insertRole设置了user\_id自增，所以就不需要再给他赋user\_id了，如果给他赋了就会报错。

测试结果：

查询成功：

![在这里插入图片描述][20200508112954168.png]

插入成功：

![在这里插入图片描述][20200508113001793.png]  
UserMapperTest和DeptMapperTest同理

[20200508112831772.png]: /images/20210813/85612dd8aa51453cb9d772598938348b.png
[20200508112855412.png]: /images/20210813/08dfff3aa76d447787e4ecc1b167d5ba.png
[20200508112905510.png]: /images/20210813/aac89899c6af4c71b4d06b6c62a79af8.png
[20200508112917516.png]: /images/20210813/2d9e68ea2e9242638156a1dfac82e23a.png
[20200508112927175.png]: /images/20210813/911acf61fe474255bd8ae893b896aa88.png
[eclipse_IDEA_Maven]: https://blog.csdn.net/weixin_45747080/article/details/105975866
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc0NzA4MA_size_16_color_FFFFFF_t_70]: /images/20210813/07d0ffde151e4f75ab515760395aa39a.png
[20200508112954168.png]: /images/20210813/cd4bd62ad8a1492cb2ba0f2ca26bb779.png
[20200508113001793.png]: /images/20210813/e662bd8cbf554586acf77cff489b2305.png