Prática de arquitetura de três camadas SpringIoC

 

 

Índice

1. Análise de requisitos

 2. Crie bancos de dados relevantes

 3. Importar dependências relacionadas

4. Preparação de classe de entidade

5. Explicações técnicas relacionadas (Druid, JDBCTemplate)

 6. Caso de implementação de arquitetura de três camadas

---

1. Análise de requisitos

Construa um caso de arquitetura de três camadas para simular a consulta de todas as informações do aluno (tabela do aluno).A camada de persistência usa tecnologia JdbcTemplate e Druid e usa XML para gerenciamento de componentes!

---

 

 2. Crie bancos de dados relevantes

create database studb;

use studb;

CREATE TABLE students (
  id INT PRIMARY KEY,
  name VARCHAR(50) NOT NULL,
  gender VARCHAR(10) NOT NULL,
  age INT,
  class VARCHAR(50)
);

INSERT INTO students (id, name, gender, age, class)
VALUES
  (1, '张三', '男', 20, '高中一班'),
  (2, '李四', '男', 19, '高中二班'),
  (3, '王五', '女', 18, '高中一班'),
  (4, '赵六', '女', 20, '高中三班'),
  (5, '刘七', '男', 19, '高中二班'),
  (6, '陈八', '女', 18, '高中一班'),
  (7, '杨九', '男', 20, '高中三班'),
  (8, '吴十', '男', 19, '高中二班');

Após a criação, o formulário ficará assim:

---

 3. Importar dependências relacionadas

  <!-- SpringIoc核心jar包 包含core ioc breans 等 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>

    <!-- junit5测试 -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>5.3.1</version> <!-- 使用属性引用JUnit Jupiter版本 -->
      <scope>test</scope>
    </dependency>

<!--        mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>

<!--        spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>6.0.6</version>
        </dependency>

<!--德鲁伊连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

---

4. Preparação de classe de entidade

package com.alphamilk;

public class Student {

    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String classes;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getClasses() {
        return classes;
    }

    public void setClasses(String classes) {
        this.classes = classes;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", classes='" + classes + '\'' +
                '}';
    }
}

---

5. Explicações técnicas relacionadas (Druid, JDBCTemplate)

Explicação técnica do JDBCTemplate

Para nos ajudar a simplificar o código em áreas específicas, o Spring encapsula muitas classes de modelo na forma de "Modelo". Por exemplo: RedisTemplate, RestTemplate, etc., incluindo o JdbcTemplate que aprenderemos hoje. jdbc.properties extrai informações de conexão do banco de dados

Usando JDBCTemplate:

package com.alphamilk;

import com.alibaba.druid.pool.DruidDataSource;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.core.JdbcTemplate;

public class test {

    @Test
    public  void Test(){

//        创建连接池对象
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/studb"); //url地址
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");//驱动信息
        dataSource.setUsername("mysql");//数据库用户名
        dataSource.setPassword("123456");//数据库密码

//    1.创建JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
//      2.传入数据连接池对象
        jdbcTemplate.setDataSource(dataSource);
//      3.实现增删查改
//       实现数据更新操作
//        jdbcTemplate.update();DDL DML DCL等非查询语句
//        jdbcTemplate.query(); DQL 查询单个对象
//        jdbcTemplate.queryForObject(); DQL 查询集合

        /*
        注意：JDBCTemplate只是简化了数据库的CRUD，并不负责提供连接池
        DruidDataSource 用于连接和创建连接池对象和数据库驱动等等
         */
    }
}

Configure dois objetos como componentes usando xml

1. Crie um arquivo de recursos pessoais na configuração do projeto e coloque nele todas as informações pessoais para modificação posterior.

alphamilk.url=jdbc:mysql://localhost:3306/studb
alphamilk.driver=com.mysql.cj.jdbc.Driver
alphamilk.username=mysql
alphamilk.password=123456

2. Escreva o arquivo de configuração xml

Crie xml, configure IoC e DI

<?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">

<!--    引入.properties文件，.properties =》 value = “${key}”-->
<!--    context:property-placeholder location="jdbc.properties","其他properties文件",,,用逗号隔开-->
    <context:property-placeholder location="jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${alphamilk.url}"/>
        <property name="driverClassName" value="${alphamilk.driver}"/>
        <property name="username" value="${alphamilk.username}"/>
        <property name="password" value="${alphamilk.password}"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

 teste:

package com.alphamilk;

import com.alibaba.druid.pool.DruidDataSource;
import com.alphamilk.pojo.Student;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

public class test {

    @Test
    public  void Test(){
//        创建Ioc容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("SpringProject.xml");
//        通过容器getBean获取组件
        DruidDataSource dataSource = (DruidDataSource) applicationContext.getBean("dataSource");
        JdbcTemplate jdbcTemplate = (JdbcTemplate) applicationContext.getBean("jdbcTemplate");
//        创建sql语句
        String sql = "insert into students (id,name,gender,age,class) values(?,?,?,?,?)";
        /*
        参数1：String sql 可以使用占位符，但是只能用于替代值，不能用于替代关键字和容器名
        参数2：Object。。。parase 传入占位符的值，并且按照从左到右的形式传递
        返回值 int 影响函数
         */
        int rows = jdbcTemplate.update(sql, 9,"黄小狗", "男", 18, "三年级一班");
        System.out.println("rows="+rows);

//        查询单条数据
         sql = "select * from students where id =?";
         /*
         参数1：可以使用占位符
         参数2：RowMapper 列名和属性名的映射器接口
         参数3：Object 。。。parase 可以传参数，替代占位符的值
          */
        Student student1 = jdbcTemplate.queryForObject(sql, new RowMapper<Student>() {
            public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
//                rs 结果集
//                rowNum 行数
//                rs结果集种获取列的值，赋值给实体类对象即可
                Student student = new Student();
                student.setId(rs.getInt("id"));
                student.setName(rs.getString("name"));
                student.setAge(rs.getInt("age"));
                student.setGender(rs.getString("gender"));
                student.setClasses(rs.getString("class"));
                return student;
            }
        }, 1);
        System.out.println("student1="+student1);

//        查询所有学生数据
//        TODO:BeanPropertyRowMapper帮助我们自动映射列和属性值！要求列名和属性名不一致！ 不一致起别名
        String sql = "select id , name , gender , age ,class as classes from students";
        List<Student> studentList =jdbcTemplate.query(sql,new BeanPropertyRowMapper<Student>(Student.class));
        System.out.println("StudentList = " +studentList);
    }
}

---

 6. Caso de implementação de arquitetura de três camadas

6.1. Camada de persistência (camada dao)

A interface correspondente à camada dao

package com.alphamilk.dao;

import com.alphamilk.pojo.Student;

import java.util.List;

public interface studentDao {
//    查询所有学生信息
    List<Student> querryAllStudent();
}

A classe de implementação correspondente à camada dao

package com.alphamilk.dao;

import com.alphamilk.pojo.Student;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

public class Impl implements studentDao{
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    @Override
    public List<Student> querryAllStudent() {
       String sql = "select id , name , gender , age ,class as classes from students";
       List<Student> students = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
        System.out.println("dao层输出"+students);
        return students;
    }
}

6.2 Camada de negócios

A interface de negócios correspondente ao serviço

package com.alphamilk.service;

import com.alphamilk.pojo.Student;

import java.util.List;

public interface StudentService {
//    业务实现查询所有的学生信息
    List<Student> findAll();
}

Métodos de implementação correspondentes à camada de negócios de serviços

package com.alphamilk.pojo.service.Imp;

import com.alphamilk.pojo.pojo.Student;
import com.alphamilk.pojo.dao.StudentDao;
import com.alphamilk.pojo.service.StudentService;

import java.util.List;

//实现类
public class StudentServiceImpl  implements StudentService {

    private StudentDao studentDao;

    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    /**
     * 查询全部学员业务
     * @return
     */
    @Override
    public List<Student> findAll() {

        List<Student> studentList =  studentDao.queryAll();

        return studentList;
    }
}

6.3 Camada de controle

package com.alphamilk.pojo.Controller;

import com.alphamilk.pojo.pojo.Student;
import com.alphamilk.pojo.service.StudentService;

import java.util.List;

public class StudentController {

    private StudentService studentService;

    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

    public void  findAll(){
       List<Student> studentList =  studentService.findAll();
        System.out.println("studentList = " + studentList);
    }
}

Corresponde a todas as configurações de arquivo XML

<?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="jdbc.properties"/>
    <!--druid-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${alphamilk.driver}"/>
        <property name="url" value="${alphamilk.url}"/>
        <property name="username" value="${alphamilk.username}"/>
        <property name="password" value="${alphamilk.password}"/>
    </bean>
<!--JDBCTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    dao层配置-->
    <bean id="studentDao" class="com.alphamilk.pojo.dao.Imp.StudentDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
<!--    service层配置-->
    <bean id="studentService" class="com.alphamilk.pojo.service.Imp.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"/>
    </bean>
<!--    controller层配置-->
    <bean id="studentController" class="com.alphamilk.pojo.Controller.StudentController">
        <property name="studentService" ref="studentService"/>
    </bean>
</beans>

teste final

package com.alphamilk;

import com.alphamilk.pojo.Controller.StudentController;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class newTest {
    @Test
    public void test(){
//        创建Ioc容器
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("SpringProject02.xml");
//        获取组件内容
        StudentController studentController = (StudentController) classPathXmlApplicationContext.getBean("studentController");
//        调用组件方法
        studentController.findAll();
//        关闭容器
        classPathXmlApplicationContext.close();
    }
}

---

Resumo baseado na arquitetura XML de três camadas:

As propriedades injetadas devem adicionar métodos setter e a estrutura do código é confusa!

Não é muito conveniente separar e escrever o arquivo de configuração e o código Java!

A eficiência de análise do arquivo de configuração XML é baixa