SpringMVC架构(Model(实体类),Service,Controller层)
Controller(接收参数调用业务层)–>Service(调用持久层，处理业务逻辑)–>Dao(与数据库交互)
1. IOC（控制反转是一种设计思想而不是技术）
DI(依赖注入):是IOC思想的一种技术实现
IOC容器是Spring提供的保存Bean对象的容器
Bean管理操作
1.Xml + 注解
2.javaConfig + 注解
通过xml配置Bean:TODO:
通过javaConfig 配置Bean:TODO:
通过注解配置Bean:TODO:
2. AOP（面向切面）
面向切面的程序设计思想。横向的调用。
eg：一个日志的功能，很多的功能模块都需要去使用，可以写一个切面去做这个事情。
使用 @Aspect 来标记一个普通类为切面。
连接点：比如说日志需要作用的方法。
目标对象：日志需要使用的对象。
1. 添加依赖
|
1 2 3 4 5 6 |
<!-- https: //mvnrepository测试数据/artifact/org.springframework/spring-aop --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version> 5.3 . 8 </version> </dependency> |
|
1 2 3 4 5 6 7 |
<!-- https: //mvnrepository测试数据/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version> 1.9 . 7 </version> <scope>runtime</scope> </dependency> |
2.demo练习
需求：SpringIOC + JDBCTemplate实现简单的数据库操作
1.新建Maven项目并引入Spring核心4依赖
|
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 |
<!--Spring的 4 个基础jar包（容器包）--> <!-- https: //mvnrepository测试数据/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version> 5.3 . 1 </version> </dependency>
<!-- https: //mvnrepository测试数据/artifact/org.springframework/spring-core --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version> 5.3 . 1 </version> </dependency>
<!-- https: //mvnrepository测试数据/artifact/org.springframework/spring-beans --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version> 5.3 . 1 </version> </dependency>
<!-- https: //mvnrepository测试数据/artifact/org.springframework/spring-expression --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version> 5.3 . 1 </version> </dependency> |
jdbc依赖
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
<!--Spring整合jdbc--> <!-- https: //mvnrepository测试数据/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version> 5.3 . 6 </version> </dependency>
<!--mysql驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version> 5.1 . 47 </version> </dependency> |
junit5
|
1 2 3 4 5 6 7 |
<!-- https: //mvnrepository测试数据/artifact/org.junit.jupiter/junit-jupiter-api --> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version> 5.3 . 2 </version> <scope>test</scope> </dependency> |
2. 创建SpringConfig配置文件（通过JavaConfig方式注入bean）
创建 SpringConfig 类，添加 @Configuration 标记为配置类。
配置数据源和 JDBCTemplate 的 Bean 。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
/** * @author YonC * @date 2021/9/2 */ @Configuration public class SpringConfig { @Bean public DataSource dataSource() { MysqlDataSource dataSource = new MysqlDataSource(); dataSource.setUrl( "jdbc:mysql://localhost:3306/test?useUnicode=ture&charactorEncoding=utf-8&serverTimezone=UTC" ); dataSource.setUser( "root" ); dataSource.setPassword( "123456" ); return dataSource; }
@Bean public JdbcTemplate jdbcTemplate(DataSource dataSource) { return new JdbcTemplate(dataSource); } } |
3.创建MVC架构并创建与数据库字段对应的实体类对象
实体类：StudentPO
|
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 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
public class StudentPO { private Long id; private String name; private String age;
public StudentPO() { }
public StudentPO(String name, String age) { this .name = name; this .age = age; }
public StudentPO(Long id, String name, String age) { this .id = id; this .name = name; this .age = age; }
public Long getId() { return id; }
public void setId(Long id) { this .id = id; }
public String getName() { return name; }
public void setName(String name) { this .name = name; }
public String getAge() { return age; }
public void setAge(String age) { this .age = age; }
@Override public String toString() { return "StudentPO{" + "id=" + id + ", name='" + name + '\ '' + ", age=" + age + '}' ; } } |
4. 编写Dao层
面向接口编程，首先定义Dao层的规范接口，定义了增删改查4种方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
/** * @author YonC * @date 2021/9/2 */ public interface StudentDao { void addStudent(StudentPO student);
void delStudentById(Long id);
void updateStudent(StudentPO student);
List<StudentPO> selectStudent(); } |
接口的实现
@Repository 注解将 StudentDao 注入IOC容器
@Autowired 自动装配 JdbcTemplate 对象, JdbcTemplate 对象已经在 SpringConfig 文件中实例化
|
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 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
/** * @author YonC * @date 2021/9/2 */ @Repository public class StudentDaoImpl implements StudentDao {
@Autowired JdbcTemplate jdbcTemplate;
/* * 增加Student * */ @Override public void addStudent(StudentPO student) { jdbcTemplate.update( "insert into student (name,age) values (?,?)" , student.getName(), student.getAge()); }
/* * 删除Student * */ @Override public void delStudentById(Long id) { jdbcTemplate.update( "delete from student where id=?" , id); }
/* * 修改Student * */ @Override public void updateStudent(StudentPO student) { String sql = "UPDATE student SET name=?,age=? where id = ? " ; Object[] args = {student.getName(), student.getAge(), student.getId()}; jdbcTemplate.update(sql, args); }
/* * 查询 * */ @Override public List<StudentPO> selectStudent() { String sql = "select id,name,age from student" ; return this .jdbcTemplate.query(sql, (rs, index) -> { StudentPO student = new StudentPO(); student.setId(rs.getLong( "id" )); student.setName(rs.getString( "name" )); student.setAge(rs.getString( "age" )); return student; }); } } |
5. Dao与数据库的增删改查已经实现，使用Service层去调用Dao层的方法。
首先定义Service层的接口
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/** * @author YonC * @date 2021/9/2 */ public interface StudentService {
void addStudent(StudentPO student);
void delStudentById(Long id);
void updateStudent(StudentPO student);
List<StudentPO> selectStudent(); } |
接口实现
@Service 将对象声明IOC容器中
@Autowired 自动装配IOC容器中的 StudentDao 将 StudentDao 对象初始化
|
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 |
/** * @author YonC * @date 2021/9/2 */ @Service public class StudentServiceImpl implements StudentService {
@Autowired StudentDao studentDao;
@Override public void addStudent(StudentPO student) { studentDao.addStudent(student); }
@Override public void delStudentById(Long id) { studentDao.delStudentById(id); }
@Override public void updateStudent(StudentPO student) { studentDao.updateStudent(student); }
@Override public List<StudentPO> selectStudent() { return studentDao.selectStudent(); } } |
6. 使用Junit5单元测试测试
首先通过IOC容器拿到StudentService对象
|
1 2 3 |
private AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig. class ); // 通过Spring的IOC容器 private StudentService studentService = applicationContext.getBean(StudentService. class ); |
测试
|
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 |
/** * @author YonC * @date 2021/9/2 */ class StudentServiceImplTest {
private AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig. class ); // 通过Spring的IOC容器 private StudentService studentService = applicationContext.getBean(StudentService. class ); @Test public void testAddStudent() {
studentService.addStudent( new StudentPO( "zahngsna" , "999" )); System.out.println( "添加成功！" ); }
@Test public void testDelStudent() { studentService.delStudentById(3L); System.out.println( "删除成功！" ); }
@Test public void testUpdateStudent() { //将id为3的Student的name修改为"wang",age修改为21 studentService.updateStudent( new StudentPO(1L, "wang" , "28" )); System.out.println( "修改成功！" ); }
@Test public void testSelectStudent() { studentService.selectStudent().forEach(System.out::println); }
} |
到此这篇关于Spring框架+jdbcTemplate实现增删改查功能的文章就介绍到这了,更多相关Spring jdbcTemplate增删改查内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
原文链接：https://blog.csdn.net/weixin_44141172/article/details/120068002
查看更多关于Spring框架+jdbcTemplate实现增删改查功能的详细内容...