JavaEE Spring基于纯注解的IOC

描述

使用基于纯注解配置的 Spring IOC，完成对用户表的增删改查操作。

题目

搭建 Spring 的开发环境，使用基于纯注解配置的 Spring IOC，完成对用户表的增删改查操作。

题目解决思路

项目环境部署

  1. 创建 Maven 项目。
  2. pom.xml 导入相关依赖。
  3. 创建持久、Entity 层
  4. 创建相关配置类。

注解解析

注解 作用
@Configuration 代替核心配置文件。
@ComponentScan 指定 Spring 在初始化容器时要扫描的包。
@Import 用于导入其他配置类。
@PropertySource 用于加载 properties 配置文件。
@Value 用于属性赋值。
@Bean 写在方法上，表明该方法创建一个对象，并放入 IOC 容器中。
@RunWith 用于 Spring 整合 Junit。
@ContextConfiguration 加载 Spring 配置文件，创建IOC容器。

项目结构

![](pic\29_JavaEE Spring.png)

前期准备

创建用户表

CREATE TABLE USER(
	id INT PRIMARY KEY AUTO_INCREMENT,
	username VARCHAR(20),
	`password` VARCHAR(20)
)

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>net.haicoder</groupId>
    <artifactId>SpringDemo11</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--IOC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
        <!--JDBC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--连接池/数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--Junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
    </dependencies>
</project>

jdbc.properties

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/haicoder_db?characterEncoding=utf8
jdbc.username = root
jdbc.password = root
jdbc.initialSize = 3
jdbc.maxActive = 50
jdbc.minIdle = 3
jdbc.maxWait = 6000

代码具体实现

Spring 配置类：

@Configuration
@ComponentScan(basePackages = "net.haicoder")
@Import(JdbcConfig.class)
public class SpringConfiguration {
}

Jdbc 配置类

// 加载jdbc.properties配置文件
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
    // 注入属性值
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    // 创建DataSource对象
    @Bean("dataSource")
    public DataSource createDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driver);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
    // 创建JdbcTemplate对象
    @Bean("jdbcTemplate")
    public JdbcTemplate createJdbcTemple(@Qualifier("dataSource") DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
}

实体类：

public class User {
    private Integer id;
    private String username;
    private String password;
    public User() {
    }
    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

持久层接口：

public interface UserDao {
    /**
     * 查找用户
     */
    List<User> findAll();
    /**
     * 根据id查询用户
     */
    User findById(Integer id);
    /**
     * 保存用户
     */
    void save(User user);
    /**
     * 更新用户
     */
    void update(User user);
    /**
     * 删除用户
     */
    void delete(Integer id);
}

持久层实现类：

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    /**
     * 查找用户
     */
    @Override
    public List<User> findAll() {
        List<User> users = jdbcTemplate.query("select * from user", new BeanPropertyRowMapper<>(User.class));
        return users;
    }
    /**
     * 根据id查询用户
     */
    @Override
    public User findById(Integer id) {
        User user = jdbcTemplate.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
        return user;
    }
    /**
     * 保存用户
     */
    @Override
    public void save(User user) {
        jdbcTemplate.update("insert into user values(null,?,?)",user.getUsername(),user.getPassword());
    }
    /**
     * 更新用户
     */
    @Override
    public void update(User user) {
        jdbcTemplate.update("update user set username=?,password=? where id=?",user.getUsername(),user.getPassword(),user.getId());
    }
    /**
     * 删除用户
     */
    @Override
    public void delete(Integer id) {
        jdbcTemplate.update("delete from user where id=?",id);
    }
}

业务层接口：

public interface UserService {
    /**
     * 查找用户
     */
    List<User> findAll();
    /**
     * 根据id查询用户
     */
    User findById(Integer id);
    /**
     * 保存用户
     */
    void save(User user);
    /**
     * 更新用户
     */
    void update(User user);
    /**
     * 删除用户
     */
    void delete(Integer id);
}

业务层实现类：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    /**
     * 查找用户
     */
    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }
    /**
     * 根据id查询用户
     *
     * @param id
     */
    @Override
    public User findById(Integer id) {
        return userDao.findById(id);
    }
    /**
     * 保存用户
     *
     * @param user
     */
    @Override
    public void save(User user) {
        userDao.save(user);
    }
    /**
     * 更新用户
     *
     * @param user
     */
    @Override
    public void update(User user) {
        userDao.update(user);
    }
    /**
     * 删除用户
     *
     * @param id
     */
    @Override
    public void delete(Integer id) {
        userDao.delete(id);
    }
}

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class DemoTest {
    @Autowired
    private UserService userService;
    @Before
    public void testBefore(){
        System.out.println("嗨客网(www.haicoder.net)\n");
    }
    @Test
    public void testFindAll(){
        // 查询所有用户
        List<User> users = userService.findAll();
        users.forEach(System.out::println);
    }
    @Test
    public void testFindUserById(){
        // 根据id查询用户
        User user = userService.findById(2);
        System.out.println(user);
    }
    @Test
    public void testAddUser(){
        // 添加用户
        User user = new User(null, "王五", "123456");
        userService.save(user);
        System.out.println("添加用户成功！");
    }
   @Test
    public void testUpdateUser(){
        // 更新用户
        User user = new User(1, "Haicoder", "abc");
        userService.update(user);
        System.out.println("更新用户成功！");
    }
    @Test
    public void testDeleteUser(){
        // 删除用户
        userService.delete(3);
        System.out.println("删除用户成功！");
    }
}

运行代码

查询所有的用户

30_JavaEE Spring.png

根据Id查询用户

31_JavaEE Spring.png

添加用户

执行代码成功，如下图：

32_JavaEE Spring.png

添加用户成功，如下图：

33_JavaEE Spring.png

更新用户

执行代码成功，如下图：

34_JavaEE Spring.png

更新用户成功，如下图：

35_JavaEE Spring.png

删除用户

执行代码成功，如下图：

36_JavaEE Spring.png

删除用户成功，如下图：

37_JavaEE Spring.png

总结

以上案例搭建 Spring 的开发环境，使用基于纯注解配置的 Spring IOC，完成对用户表的增删改查操作。
嗨客网教程
嗨客网首页 首页 嗨客网知识体系 知识体系 嗨客网实战 实战 嗨客网随笔 随笔 嗨客网搜索 搜索