Spring Boot初步教程+多模块+jdbcTemplate初探

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量200 收藏 2
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30473913/article/details/115947952
版权

编辑器使用IDEA

  1. 打开IDEA后新建工程
    在这里插入图片描述

  2. 选择Maven，然后选下一步
    在这里插入图片描述

  3. 输入GroupId和ArtifactId，然后Finish
    在这里插入图片描述

  4. 新建多模块，比如MySql模块在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

  1. 在根项目中的pom.xml添加parent，然后所有的子模块都可以使用此parent中的jar，如添加：
<parent>
	 <groupId>org.springframework.boot</groupId>
	 <artifactId>spring-boot-starter-parent</artifactId>
	 <version>2.1.0.RELEASE</version>
</parent>

在这里插入图片描述

  1. 在根项目中添加dependencies和dependency，所有子模块都可以使用此依赖，如：
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
        <version>2.1.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>2.1.0.RELEASE</version>
        <scope>test</scope>
    </dependency>
</dependencies>

在这里插入图片描述

  1. 在新建的模块的pom.xml添加mysql的依赖包
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
        <version>2.1.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.13</version>
    </dependency>
</dependencies>

  1. 新建一个数据库，本人用的是Navicat Premium，这里不再赘述，然后新建一张表，如User表，插入一些数据供测试使用
    在这里插入图片描述

  2. 在模块中创建相应的package，结构差不多如下
    在这里插入图片描述

  3. rescources中创建一个application.yml文件，配置连接mysql的参数
    在这里插入图片描述
    注意这里的username、password要和数据库相对应，否则无法连接

  4. 在bean中创建一个User类，此类对应数据库表tb_user，并且每个变量对应一个字段，如：

package com.joel.mysql.bean;

import java.util.Date;

public class User {
   private int id;
   private String username;
   private int age;
   private Date ctm;

   public User() {
   }

   public User(String username, int age) {
       this.username = username;
       this.age = age;
       this.ctm = new Date();
   }

   public int getId() {
       return id;
   }

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

   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public int getAge() {
       return age;
   }

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

   public Date getCtm() {
       return ctm;
   }

   public void setCtm(Date ctm) {
       this.ctm = ctm;
   }
}

在这里插入图片描述

  1. 创建一个UserDao接口，如：
package com.joel.mysql.dao;

import com.joel.mysql.bean.User;

import java.util.List;

public interface UserDao {
    public User getUserById(Integer id);
    public List<User> getUserList();
    public int add(User user);
    public int update(Integer id, User user);
    public int delete(Integer id);
}

在这里插入图片描述

  1. 在dao包中创建一个impl包，并创建一个UserDaoImpl类用来实现UserDao接口，此类中有JdbcTemplate，添加@Autowired，Spring-boot会自动读取配置文件中的信息到JdbcTemplate中，然后通过JdbcTemplate就可以进行RCUD了，如：
    在这里插入图片描述
package com.joel.mysql.dao.impl;

import com.joel.mysql.bean.User;
import com.joel.mysql.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.Date;
import java.util.List;

@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public User getUserById(Integer id) {
        List<User> list = jdbcTemplate.query("select * from tb_user where id = ?", new Object[]{id}, new BeanPropertyRowMapper(User.class));
        if(list!=null && list.size()>0){
            return list.get(0);
        }else{
            return null;
        }
    }

    @Override
    public List<User> getUserList() {
        List<User> list = jdbcTemplate.query("select * from tb_user", new Object[]{}, new BeanPropertyRowMapper(User.class));
        if(list!=null && list.size()>0){
            return list;
        }else{
            return null;
        }
    }

    @Override
    public int add(User user) {
        return jdbcTemplate.update("insert into tb_user(username, age, ctm) values(?, ?, ?)",
                user.getUsername(),user.getAge(), new Date());
    }

    @Override
    public int update(Integer id, User user) {
        return jdbcTemplate.update("UPDATE tb_user SET username = ? , age = ? WHERE id=?",
                user.getUsername(),user.getAge(), id);
    }

    @Override
    public int delete(Integer id) {
        return jdbcTemplate.update("DELETE from tb_user where id = ? ",id);
    }
}
  1. 在service包中创建一个UserService接口，如：
    在这里插入图片描述
package com.joel.mysql.service;

import com.joel.mysql.bean.User;

import java.util.List;

public interface UserService {
    public User getUserById(Integer id);
    public List<User> getUserList();
    public int add(User user);
    public int update(Integer id, User user);
    public int delete(Integer id);
}
  1. 在service包中创建一个impl包，并创建一个UserServiceImpl类用来实现UserService接口
    在这里插入图片描述
package com.joel.mysql.service.impl;

import com.joel.mysql.bean.User;
import com.joel.mysql.dao.UserDao;
import com.joel.mysql.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public User getUserById(Integer id) {
        return userDao.getUserById(id);
    }

    @Override
    public List<User> getUserList() {
        return userDao.getUserList();
    }

    @Override
    public int add(User user) {
        return userDao.add(user);
    }

    @Override
    public int update(Integer id, User user) {
        return userDao.update(id, user);
    }

    @Override
    public int delete(Integer id) {
        return userDao.delete(id);
    }
}
  1. 在bean包中创建一个JsonResult类，用来返回接口信息
    在这里插入图片描述
package com.joel.mysql.bean;

public class JsonResult {
    private String status = null;
    private Object result = null;
    public JsonResult status(String status) {
        this.status = status;
        return this;
    }
    public void setResult(Object user){
        this.result=user;
    }
    public Object getResult(){
        return this.result;
    }
    public void setStatus(String status){
        this.status=status;
    }
    public String getStatus(){
        return this.status;
    }
}
  1. 在web包中创建一个控制类UserController，用来处理http请求
    在这里插入图片描述
package com.joel.mysql.web;

import com.joel.mysql.bean.JsonResult;
import com.joel.mysql.bean.User;
import com.joel.mysql.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class UserConrroller {
    @Autowired
    private UserService userService;

    /**
     * 根据ID查询用户
     * @param id
     * @return
     */
    @RequestMapping(value = "user/{id}", method = RequestMethod.GET)
    public ResponseEntity<JsonResult> getUserById (@PathVariable(value = "id") Integer id){
        JsonResult r = new JsonResult();
        try {
            User user = userService.getUserById(id);
            r.setResult(user);
            r.setStatus("ok");
        } catch (Exception e) {
            r.setResult(e.getClass().getName() + ":" + e.getMessage());
            r.setStatus("error");
            e.printStackTrace();
        }
        return ResponseEntity.ok(r);
    }

    /**
     * 查询用户列表
     * @return
     */
    @RequestMapping(value = "users", method = RequestMethod.GET)
    public ResponseEntity<JsonResult> getUserList (){
        JsonResult r = new JsonResult();
        try {
            List<User> users = userService.getUserList();
            r.setResult(users);
            r.setStatus("ok");
        } catch (Exception e) {
            r.setResult(e.getClass().getName() + ":" + e.getMessage());
            r.setStatus("error");
            e.printStackTrace();
        }
        return ResponseEntity.ok(r);
    }

    /**
     * 添加用户
     * @param user
     * @return
     */
    @RequestMapping(value = "user", method = RequestMethod.POST)
    public ResponseEntity<JsonResult> add (@RequestBody User user){
        JsonResult r = new JsonResult();
        try {
            int orderId = userService.add(user);
            if (orderId < 0) {
                r.setResult(orderId);
                r.setStatus("fail");
            } else {
                r.setResult(orderId);
                r.setStatus("ok");
            }
        } catch (Exception e) {
            r.setResult(e.getClass().getName() + ":" + e.getMessage());
            r.setStatus("error");

            e.printStackTrace();
        }
        return ResponseEntity.ok(r);
    }

    /**
     * 根据id删除用户
     * @param id
     * @return
     */
    @RequestMapping(value = "user/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<JsonResult> delete (@PathVariable(value = "id") Integer id){
        JsonResult r = new JsonResult();
        try {
            int ret = userService.delete(id);
            if (ret < 0) {
                r.setResult(ret);
                r.setStatus("fail");
            } else {
                r.setResult(ret);
                r.setStatus("ok");
            }
        } catch (Exception e) {
            r.setResult(e.getClass().getName() + ":" + e.getMessage());
            r.setStatus("error");

            e.printStackTrace();
        }
        return ResponseEntity.ok(r);
    }

    /**
     * 根据id修改用户信息
     * @param user
     * @return
     */
    @RequestMapping(value = "user/{id}", method = RequestMethod.PUT)
    public ResponseEntity<JsonResult> update (@PathVariable("id") Integer id, @RequestBody User user){
        JsonResult r = new JsonResult();
        try {
            int ret = userService.update(id, user);
            if (ret < 0) {
                r.setResult(ret);
                r.setStatus("fail");
            } else {
                r.setResult(ret);
                r.setStatus("ok");
            }
        } catch (Exception e) {
            r.setResult(e.getClass().getName() + ":" + e.getMessage());
            r.setStatus("error");

            e.printStackTrace();
        }
        return ResponseEntity.ok(r);
    }
}
  1. 在包根路径下创建一个spring-boot的启动类Application
    在这里插入图片描述
package com.joel.mysql;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableAutoConfiguration
@SpringBootApplication
public class Application {

    public static void main( String[] args ) {
        System.out.println( "start....." );
        SpringApplication.run(Application.class, args);
    }
}

  • 允许此类
    在这里插入图片描述

  • 在浏览器中输入：http://127.0.0.1:8080/users即可输入结果
    在这里插入图片描述

  • 对于add、delete、update方法可以使用PostMan来模拟发送请求，具体使用方法请移步PostMan使用方法

以上

总结一下：

  • 在程序启动时，在Application.java类中有一个@SpringBootApplication注解，它包含了@Configuration + @EnableAutoConfiguration + @ComponentScan三个注解，说明在启动时会自动获取配置（比如配置的数据库连接参数等
  • 运行main，进而运行SpringApplication.run(Application.class, args);然后开始进行初始化Spring相关的信息，比如其他类的注解
  • 当从浏览器中输入网址时，spring就会去找被@RestController的相应的类，然后进行路径解析，然后@RequestMapping来注释具体调用的是那个路径下的方法，如：@RequestMapping(value = “users”, method = RequestMethod.GET)，根路径为：http://127.0.0.1:8080,如果加上value，那么就会自动匹配成http://127.0.0.1:8080/users，然后在进一步判断http请求的方法，如果为：RequestMethod.GET，则会调用getUserList ()； -
  • 在getUserList ()方法中会有一个userService.getUserList()，此处的userService通过@Service已经实例化为了UserServiceImpl类，那么此时调用的userService.getUserList()就会调用UserServiceImpl类中的getUserList()。
  • 在UserServiceImpl类中的getUserList()方法中会调用userDao.getUserList()方法，而userDao通过@Repository已经实例化为了UserDaoImpl类，那么此时调用的userDao.getUserList()就会调用UserDaoImpl类中的getUserList()方法。
  • 在UserDaoImpl类中的getUserList()方法中通过jdbcTemplate.query(“select * from tb_user”, new Object[]{}, new BeanPropertyRowMapper(User.class))，对数据表进行查询，而jdbcTemplate则是在spring-boot启动时会自动配置数据库的相关连接，直接可以使用。
  • 把查询结果生成一个List，然后返回到UserController中，并构造一个JsonResult对象，然后通过ResponseEntity对象构造成一个json格式对象，然后返回到浏览器中
飞天小蜗牛
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring boot jdbctemplate为null_Spring Boot2 系列教程(二十)Spring Boot 整合JdbcTemplate 多数据源...
weixin_36168447的博客
01-15 807
多数据源配置也算是一个常见的开发需求，Spring 和 SpringBoot 中，对此都有相应的解决方案，不过一般来说，如果有多数据源的需求，我还是建议首选分布式数据库中间件 MyCat 去解决相关问题，之前有小伙伴在我的知识星球上提问，他的数据根据条件的不同，可能保存在四十多个不同的数据库中，怎么办？这种场景下使用多数据源其实就有些费事了，我给的建议是使用 MyCat，然后分表策略使用...
SpringBoot整合JdbcTemplate
weixin_42522705的博客
08-27 1193
Spring对数据库的操作在jdbc上面做了更深层次的封装，而JdbcTemplate便是Spring提供的一个操作数据库的便捷工具。我们可以借助JdbcTemplate来执行所有数据库操作，例如插入，更新，删除和从数据库中检索数据，并且有效避免直接使用jdbc带来的繁琐编码以上就是SpringBoot整合JdbcTemplate基本内容，其它内容以后慢慢研究。.........
springboot-12-JDBCTemplate
paiidds的博客
03-19 1107
JDBCTemplate     引入spring-boot-starter-jdbc,引入了默认的数据源(com.zaxxer.hikari.HikariDataSource),拿到数据库连接，我们就可以操作数据库了，Spring本身对原生的JDBC做了轻量级的封装，即JdbcTemplate。     数据库的CRUD方法都在JdbcTemplate中，Spring Boot除了帮我们配置默认的数据源，还给我们配置好了JdbcTemplate在容器中，程序员只需要注入即可使用,JdbcTemplate的
Spring Boot 整合JdbcTemplate
热门推荐
探索er的博客
04-04 1万+
整合JdbcTemplate
template.java_详解spring boot中使用JdbcTemplate
weixin_34262786的博客
02-25 281
本文将介绍如何将spring boot 与 JdbcTemplate一起工作。Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 JdbcTemplate 是在JDBC API基础上提供了更抽象的封装，并提供了基于方法注解的事务管理能力。 通过使用SpringBoot自动配置功能并代替我们自动配置be...
spring boot 2.0.2 + spring batch + jdbcTemplate 实现读取csv文件数据插入mysql数据库
qq_30517167的博客
03-04 1149
源码：链接: https://pan.baidu.com/s/1Tt3-s1dj-EfcZ4dvR3O42A 提取码: 5p3c
图书管理系统( Spring+Spring MVC+JdbcTemplate).rar
12-25
《图书管理系统：基于Spring+SpringMVC+JdbcTemplate的实现详解》 图书管理系统是信息化建设中的重要组成部分，它能够高效地管理和维护图书馆的资源，提供便捷的服务给读者和管理员。本系统采用主流的Spring框架、...
基于spring boot 1.5.4 集成 jpa+hibernate+jdbcTemplate(详解)
08-30
在Spring Boot 1.5.4版本中，集成JPA（Java Persistence API）、Hibernate和JdbcTemplate可以帮助我们构建高效、便捷的数据访问层。JPA是Java平台上的一个标准，用于管理和持久化应用程序对象到关系数据库。...
基于java+Spring+SpringMVC+JDBCTemplate+JSP开发的博客论坛系统+源码+开发文档+视频演示
03-23
基于java+Spring+SpringMVC+JDBCTemplate+JSP开发的博客论坛系统+源码+开发文档+视频演示，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于java+Spring+...
Spring boot +jdbctemplate
11-05
- **配置多数据源**：在Spring Boot中，可以通过配置多个数据源和切换策略来支持复杂的多数据源应用场景。 综上所述，Spring Boot与JdbcTemplate的结合，为开发高效、简洁的Java Web应用提供了强大支持。通过自动...
Java图书管理系统( Spring+Spring MVC+JdbcTemplate)
01-15
Java图书管理系统是一个基于Spring、Spring MVC和JdbcTemplate技术构建的应用，旨在实现全面的图书管理功能。这个系统不仅涵盖了用户管理，如读者和管理员的登录，还包括了图书资源的管理，如图书的添加、删除、修改...
在Spring中初始化输出JdbcTemplate对象正在使用的数据源信息
weixin_52863669的博客
12-15 676
首先是配置JdbcTemplate <!-- 为IOC容器配置一个JdbcTemplate --> <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate"> <property name="dataSource" ref="myDateSource"/> </bean> 引用数据库 <bean class="com.jdbcTemplate_data
Spring5.0源码:jdbcTemplate
weixin_37571795的博客
09-04 712
数据库连接JDBC jdbcTemplate的初始化是从DataSource开始的。 DataSource实例通过参数注入，DataSource的创建过程是可引入第三方的连接池。 DataSource是整个数据库操作的基础，其封装了整个数据库的连接信息。 例: 配置好dataSource后 jdbcTemplate.update---->update—>execute update可...
SpringBoot 整合 JdbcTemplate（配置多数据源）
usa_washington的博客
11-19 1668
SpringBoot整合JdbcTemplate
springboot整合jdbctemplate教程
沐雨橙风ιε的博客
08-26 1753
springboot整合jdbctemplate教程
SpringBoot系列之数据库初始化-datasource配置方式
mxt51220的博客
12-23 5235
在我们的日常业务开发过程中，如果有db的相关操作，通常我们是直接建立好对应的库表结构，并初始化对应的数据，即更常见的情况下是我们在已有表结构基础之下，进行开发；但是当我们是以项目形式工作时，更常见的做法是所有的库表结构变更、数据的初始、更新等都需要持有对应的sql变更，并保存在项目工程中，这也是使用liqubase的一个重要场景；将上面的问题进行简单的翻译一下，就是如何实现在项目启动之后执行相应的sql，实现数据库表的初始化？
springboot 整合JdbcTemplate
虾米大王的学习历程
08-09 908
Spring Boot中对JdbcTemplate的使用提供了自动化配置类JdbcTemplateAutoConfiguration，当classpath下存在DataSource和JdbcTemplate并且DataSource只有一个实例时，自动配置才会生效，若开发者没有提供JdbcOperations，则Spring Boot会自动向容器中注入一个JdbcTemplate（JdbcTemplate是JdbcOperations的子类）。• 创建BookDao，注入JdbcTemplate。
Java内存模型
最新发布
weixin_44267758的博客
07-19 310
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Spring Boot 教程：从 HelloWorld 到实战解析
这篇Spring Boot学习笔记涵盖了从基础到高级的多个主题，旨在帮助读者全面掌握Spring Boot框架。以下是笔记中的关键知识点： 1. **Spring Boot HelloWorld**: 这是入门的基础，展示了如何创建一个简单的Spring Boot...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值