Idea创建Maven多模块+Spring-boot jdbctemplate的使用

最新推荐文章于 2024-05-09 14:49:10 发布
最新推荐文章于 2024-05-09 14:49:10 发布
阅读量4.1k 收藏 3
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunxiaoju/article/details/84343002
版权

1、在打开Idea后选择Create New Project，如下图所示：

2、选择Maven，然后不要选Create from archetype，直接点击Next，如下图所示：

3、输入GroupId和ArtifactId，然后点击Next，如下图所示：

4、输入工程名称以及路径，然后点击Finish，如下图所示：

5、创建好之后如下图所示的目录结构：

6、右键单击src，然后在弹出的菜单中选择Delete，将其删除，如下图所示：

7、然后在项目名称上右键单击，依次选择New->Module，如下图所示：

8、然后选择Maven，直接单击Next，如下图所示：

9、然后只需要输入ArtifactId即可，如下图所示：

10、输入模块的名称，如下图所示：

11、如果出现Maven projects need to be imported，选择Enable Auto-Import表示自动导入，如下图所示：

12、在根项目中的pom.xml添加parent，然后所有的子模块都可以使用此parent中的jar，如添加：

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>

13、在根项目中添加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>

14、在mysql模块中的pom.xml添加连接mysql相应的jar包，如：

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

15、新建一个demo数据库，如下图所示：

16、创建一个tb_user表，如：

CREATE TABLE `tb_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `username` varchar(50) NOT NULL COMMENT '用户名',
  `age` int(11) NOT NULL COMMENT '年龄',
  `ctm` datetime NOT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

17、插入相应的数据，如：

INSERT INTO `demo`.`tb_user` (`username`, `age`, `ctm`) VALUES('张三', '18', NOW()) ;
INSERT INTO `demo`.`tb_user` (`username`, `age`, `ctm`) VALUES('李四', '20', NOW()) ;
INSERT INTO `demo`.`tb_user` (`username`, `age`, `ctm`) VALUES('王五', '19', NOW()) ;

18、最后结果如下图所示：

19、在mysql模块中创建相应的包，结构如下图所示：

20、在resources创建一个application.yml文件，配置连接mysql的字符串（注意：每一项的冒号后都要有一个空格，否则会出错），如下图所示：

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

package com.win.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 void setUsername(String username){
        this.username=username;
    }
    public void setAge(int age){
        this.age=age;
    }
    public void setCtm(Date ctm){
        this.ctm=ctm;
    }
    public int getId(){
        return this.id;
    }
    public String getUsername(){
        return this.username;
    }
    public int getAge(){
        return this.age;
    }
    public Date getCtm(){
        return this.ctm;
    }
}

22、创建一个UserDao接口，如：

package com.win.mysql.dao;

import com.win.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);
}

23、在dao包中创建一个impl包，并创建一个UserDaoImpl类用来实现UserDao接口，此类中有JdbcTemplate，Spring-boot会自动读取配置文件中的信息到JdbcTemplate中，然后通过JdbcTemplate就可以进行RCUD了，如：

package com.win.mysql.dao.impl;

import com.win.mysql.bean.User;
import com.win.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);
    }
}

24、在service包中创建一个UserService接口，如：

package com.win.mysql.service;

import com.win.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);
}

25、在service包中创建一个impl包，并创建一个UserServiceImpl类用来实现UserService接口，如：

package com.win.mysql.service.impl;

import com.win.mysql.bean.User;
import com.win.mysql.dao.UserDao;
import com.win.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);
    }
}

26、在bean包中创建一个JsonResult类，如：

package com.win.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;
    }
}

27、在web包中创建一个控制类UserController，通过http请求的都在此类中，如：

package com.win.mysql.web;

import com.win.mysql.bean.JsonResult;
import com.win.mysql.bean.User;
import com.win.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 UserController {
    @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);
    }
}

28、在mysql包中创建一个spring-boot的启动类Application，如：

package com.win.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);
    }
}

29、在启动后出现错误，如：

java.sql.SQLException: The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the serverTimezone configuration property) to use a more specifc time zone value if you want to utilize time zone support.
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:129) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:97) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:89) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:63) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.exceptions.SQLError.createSQLException(SQLError.java:73) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.exceptions.SQLExceptionsMapping.translateException(SQLExceptionsMapping.java:76) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:835) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.ConnectionImpl.<init>(ConnectionImpl.java:455) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.ConnectionImpl.getInstance(ConnectionImpl.java:240) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.NonRegisteringDriver.connect(NonRegisteringDriver.java:207) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.zaxxer.hikari.util.DriverDataSource.getConnection(DriverDataSource.java:136) ~[HikariCP-3.2.0.jar:na]
	at com.zaxxer.hikari.pool.PoolBase.newConnection(PoolBase.java:369) ~[HikariCP-3.2.0.jar:na]
	at com.zaxxer.hikari.pool.PoolBase.newPoolEntry(PoolBase.java:198) ~[HikariCP-3.2.0.jar:na]
	at com.zaxxer.hikari.pool.HikariPool.createPoolEntry(HikariPool.java:467) [HikariCP-3.2.0.jar:na]
	at com.zaxxer.hikari.pool.HikariPool.checkFailFast(HikariPool.java:541) [HikariCP-3.2.0.jar:na]
	at com.zaxxer.hikari.pool.HikariPool.<init>(HikariPool.java:115) [HikariCP-3.2.0.jar:na]
	at com.zaxxer.hikari.HikariDataSource.getConnection(HikariDataSource.java:112) [HikariCP-3.2.0.jar:na]
	at org.springframework.jdbc.datasource.DataSourceUtils.fetchConnection(DataSourceUtils.java:151) [spring-jdbc-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.jdbc.datasource.DataSourceUtils.doGetConnection(DataSourceUtils.java:115) [spring-jdbc-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.jdbc.datasource.DataSourceUtils.getConnection(DataSourceUtils.java:78) [spring-jdbc-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.jdbc.support.JdbcUtils.extractDatabaseMetaData(JdbcUtils.java:319) [spring-jdbc-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.jdbc.support.JdbcUtils.extractDatabaseMetaData(JdbcUtils.java:356) [spring-jdbc-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.boot.autoconfigure.orm.jpa.DatabaseLookup.getDatabase(DatabaseLookup.java:72) [spring-boot-autoconfigure-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.autoconfigure.orm.jpa.JpaProperties.determineDatabase(JpaProperties.java:142) [spring-boot-autoconfigure-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.autoconfigure.orm.jpa.JpaBaseConfiguration.jpaVendorAdapter(JpaBaseConfiguration.java:112) [spring-boot-autoconfigure-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaConfiguration$$EnhancerBySpringCGLIB$$94d70ee3.CGLIB$jpaVendorAdapter$4(<generated>) [spring-boot-autoconfigure-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaConfiguration$$EnhancerBySpringCGLIB$$94d70ee3$$FastClassBySpringCGLIB$$c0920c0.invoke(<generated>) [spring-boot-autoconfigure-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.cglib.proxy.MethodProxy.invokeSuper(MethodProxy.java:244) [spring-core-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.context.annotation.ConfigurationClassEnhancer$BeanMethodInterceptor.intercept(ConfigurationClassEnhancer.java:363) [spring-context-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaConfiguration$$EnhancerBySpringCGLIB$$94d70ee3.jpaVendorAdapter(<generated>) [spring-boot-autoconfigure-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_181]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_181]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_181]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_181]
	at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:154) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:620) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.instantiateUsingFactoryMethod(ConstructorResolver.java:455) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(AbstractAutowireCapableBeanFactory.java:1288) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1127) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:538) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:498) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:273) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1239) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1166) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.resolveAutowiredArgument(ConstructorResolver.java:855) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.createArgumentArray(ConstructorResolver.java:758) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.instantiateUsingFactoryMethod(ConstructorResolver.java:508) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(AbstractAutowireCapableBeanFactory.java:1288) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1127) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:538) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:498) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:273) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1239) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1166) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.resolveAutowiredArgument(ConstructorResolver.java:855) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.createArgumentArray(ConstructorResolver.java:758) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.ConstructorResolver.instantiateUsingFactoryMethod(ConstructorResolver.java:508) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(AbstractAutowireCapableBeanFactory.java:1288) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1127) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:538) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:498) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:320) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222) ~[spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199) [spring-beans-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1083) ~[spring-context-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:853) ~[spring-context-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:546) ~[spring-context-5.1.2.RELEASE.jar:5.1.2.RELEASE]
	at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:140) ~[spring-boot-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:775) ~[spring-boot-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:397) ~[spring-boot-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:316) ~[spring-boot-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1260) ~[spring-boot-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1248) ~[spring-boot-2.1.0.RELEASE.jar:2.1.0.RELEASE]
	at com.win.mysql.Application.main(Application.java:13) ~[classes/:na]
Caused by: com.mysql.cj.exceptions.InvalidConnectionAttributeException: The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the serverTimezone configuration property) to use a more specifc time zone value if you want to utilize time zone support.
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) ~[na:1.8.0_181]
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) ~[na:1.8.0_181]
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) ~[na:1.8.0_181]
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423) ~[na:1.8.0_181]
	at com.mysql.cj.exceptions.ExceptionFactory.createException(ExceptionFactory.java:61) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.exceptions.ExceptionFactory.createException(ExceptionFactory.java:85) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.util.TimeUtil.getCanonicalTimezone(TimeUtil.java:132) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.protocol.a.NativeProtocol.configureTimezone(NativeProtocol.java:2234) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.protocol.a.NativeProtocol.initServerSession(NativeProtocol.java:2258) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.ConnectionImpl.initializePropsFromServer(ConnectionImpl.java:1319) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.ConnectionImpl.connectOneTryOnly(ConnectionImpl.java:966) ~[mysql-connector-java-8.0.13.jar:8.0.13]
	at com.mysql.cj.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:825) ~[mysql-connector-java-8.0.13.jar:8.0.13]

30、出现此错误说明在连接mysql时的时区不对，只需要在连接串后加上?serverTimezone=UTC即可，如下图所示：

31、再次启动即可启动成功，如下图所示：

32、在浏览器中输入：http://127.0.0.1:8080/users即可输入结果，如下图所示：

33、在输出结果可以看到其中的id全部是0，这是由于在User类中缺少setId方法，只需要添加即可，如下图所示：

34、在此刷新即可正常输入，如下图所示：

35、在浏览器中输入：http://127.0.0.1:8080/user/1即可查询指定用户，如下图所示：

36、使用火狐浏览器中的RESTClient插件进行测试添加用户，选择post请求，然后输入：http://127.0.0.1:8080/user，然后添加HTTP头，输入正文，点击发送即可添加，并且有返回状态，如下图所示：

37、在此查询所有用户即可显示，如下图所示：

38、修改用户信息，选择put请求，然后输入：http://127.0.0.1:8080/user/1，输入要修改的内容，表示修改指定ID的信息，点击发送即可修改，并且有返回状态，如下图所示：

39、在此刷新可以看到已经更新了，如下图所示：

40、删除用户信息，选择DELETE请求，然后输入：http://127.0.0.1:8080/user/1，不需要输入内容，点击发送即可删除，并且有返回状态，如下图所示：

41、再次刷新显示ID为1的已经被删除，如下图所示：

 

总结：

（1）在程序启动时，在Application.java类中有一个@SpringBootApplication注解，它包含了@Configuration + @EnableAutoConfiguration + @ComponentScan三个注解，说明在启动时会自动获取配置（比如配置的数据库连接参数等）

（2）然后在去运行main，进而运行SpringApplication.run(Application.class, args);然后开始进行初始化Spring相关的信息，比如其他类的注解。

（3）当从浏览器中输入网址时，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 ()；

（4）在getUserList ()方法中会有一个userService.getUserList()，此处的userService通过@Service已经实例化为了UserServiceImpl类，那么此时调用的userService.getUserList()就会调用UserServiceImpl类中的getUserList()。

（5）在UserServiceImpl类中的getUserList()方法中会调用userDao.getUserList()方法，而userDao通过@Repository已经实例化为了UserDaoImpl类，那么此时调用的userDao.getUserList()就会调用UserDaoImpl类中的getUserList()方法。

（6）在UserDaoImpl类中的getUserList()方法中通过jdbcTemplate.query("select * from tb_user", new Object[]{}, new BeanPropertyRowMapper(User.class))，对数据表进行查询，而jdbcTemplate则是在spring-boot启动时会自动配置数据库的相关连接，直接可以使用。

（7）把查询结果生成一个List，然后返回到UserController中，并构造一个JsonResult对象，然后通过ResponseEntity对象构造成一个json格式对象，然后返回到浏览器中。

 

sxjlinux
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
在idea下使用JDBCTemplate实现登录功能
qq_42487559的博客
02-17 2395
需求 1.编写login.html登录页面 2.使用Druid数据库连接池技术,操作mysql。 3.使用JdbcTemplate技术封装JDBC 4.登录成功跳转到（请求转发）Success页面，显示：用户名登录成功！ 5.登录失败跳转到Fail页面，显示：登录失败，用户名或密码错误 步骤 1. 创建项目，写login.html页面,导入相关jar包，导入druid.propert...
JdbcTemplate
LeGuan_Ha的博客
10-09 313
Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作。
maven+Spring+JdbcTemplate
m0_66918076的博客
04-23 1193
maven+Spring+JdbcTemplate
(IDEA)Spring的数据库编程-JdbcTemplate
qq_74329022的博客
05-09 906
在MySQL中，可以使用execute方法来执行各种SQL语句，如create（创建表）、drop（删除表）、alter（修改表结构）、truncate（清空表数据）、rename（重命名表）等操作。通过使用update语句，可以指定要更新的表名、要更新的字段和对应的数值，以及更新的条件。通过使用select语句，可以指定要查询的字段、要查询的表名，以及查询的条件。简化的API：JdbcTemplate提供了一组简单易用的方法来执行常见的数据库操作，例如查询、更新和存储过程调用。
Maven配置JdbcTemplate完成数据查询
热门推荐
TianXinCoord的博客
10-09 1万+
目录 一、文章前言 二、使用步骤 2.1 配置Maven依赖 2.2 配置实体类 2.3 配置Spring文件 2.4 配置测试类 2.5 运行结果 一、文章前言     1.本篇文章使用Idea中使用Maven配置JdbcTemplate完成数据的查询     2.测试使用的版本为最新版：5.0.9.RELEASE系列     3.采用的是Spring+oracle+dbc...
使用idea工具创建springboot项目，SpringBoot整合JDBC
weixin_38568503的博客
11-17 1324
一、Spring Boot整合JDBCTemplatedbc： 前言： 在使用JDBCTemplate之前，我们先来了解一下JDBC。它是java用于连接数据库的规范，也就是用于执行数据库SQL语句的java API。是由一组用java语言编写的类和接口组成，为大部分关系型数据库提供了访问接口。 而JDBC每次使用前进行数据库的连接，然后处理SQL语句、传值、关闭数据库等，如果都由开发人员编写代码，很容易出错，可能会出现在使用完成以后，数据库连接忘记关闭的情况，从而导致连接被占用降低性能，为了减少这种可能的
IDEA中使用springJDBCTemplate以及相关问题解决
wangcheng__的博客
10-09 2257
** 1、创建springboot项目环境搭建 ** 本文主要讲述直接通过 第一步spring initializr 第二步 第三步 第四步 点finish就可以已完成。 注意如果你在第三步没有选或者少选了相关依赖 你可以百度其相关依赖到pop。xml中。然后点击如图 ** 2、注入依赖产生相关问题及解决方案 ** 2.1出现spring.datasource.driver-class-name=com.mysql.jdbc.Driver爆红解决方案是：出现问题1.看pop.xml文件下是否添加
idea配置maven+Springboot+mybatis+oracle
08-23
本知识点将详细介绍如何在Idea中配置Maven、Spring Boot、MyBatis以及Oracle数据库，实现一个完整的Java Web项目架构。 **一、配置Maven** 1. **安装Maven**: 首先确保你的系统中已经安装了Maven，可以在命令行...
spring-boot项目示例学习demo-66套.zip
最新发布
05-17
IntelliJ IDEA ULTIMATE 2018.2 + (注意：务必使用 IDEA 开发，同时保证安装 lombok 插件) Mysql 5.7 + (尽量保证使用 5.7 版本以上，因为 5.7 版本加了一些新特性，同时不向下兼容。本 demo 里会尽量避免这种不兼容...
Springboot+maven+idea+mysql实战之获取数据库信息显示在前端
12-21
在本教程中，我们将探讨如何使用Spring Boot、Maven、IntelliJ IDEA和MySQL数据库创建一个实战项目，目的是从数据库获取信息并在前端展示。首先，我们需要确保我们的开发环境已准备就绪，包括安装IntelliJ IDEA作为...
JavaEE颠覆者spring-boot实战源码.zip
05-30
例如，如果你的项目包含了JDBC的依赖，Spring Boot就会自动配置DataSource和JdbcTemplate。 3. **起步依赖（Starters）**： Starters是一系列的Maven或Gradle模块，用于简化构建过程。例如，`spring-boot-starter-...
maven-spring-mybatis
06-01
10. **运行与调试**：项目可以通过Maven的`mvn spring-boot:run`命令启动，或者通过IDE（如IntelliJ IDEA或Eclipse）直接运行。调试可以通过断点和日志输出进行。 以上就是关于"maven-spring-mybatis"项目的主要...
Spring JdbcTemplate基本使用(基于maven)简洁版
qq_46199553的博客
08-05 1453
JdbcTemplate在现在用得并不多，使用mybatis更多一些 1.1 JdbcTemplate概述 它是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。 1.2 JdbcTemplate开发步骤 导入spring-jdbc和spring-tx坐标 创
idea版本Spring使用JdbcTemplate方式-德鲁伊连接池-连接sqlServer2012
程序员象漂亮的博客
11-30 1137
B站尚硅谷spring-JdbcTemplate连接 参考sqlServer驱动博客 背景：从springboot转头来再过一次spring，使用尚硅谷的教程学习。 解决问题：视频中用的是mysql，但公司用的是sqlServer2012，于是使用sqlServer2012数据库。 1：jar包（注意sqlijdbc4.jar这个包，里面就包含了com.XXX.XXX.jdbc的驱动） 2、在Spring配置文件配置数据库连接池 <!--数据库连接池--> <bean i
idea创建springboot+jdbcTemplate多数据源
殇之何伤的博客
03-23 676
一、Idea创建工程 进入Idea ，file-->new->project... Next (环境、版本号等设置) Next （选择核心依赖组件） Next （给新建的项目起个名字，以及设置保存地址、工作目录） Finish，完后项目创建。 二、创建工程层级目录 config:多数据源配置目录 controller：请求入口，控制层 dao：持久层，jdbcTemplate操作数据库 pojo：数据库表对应的实体对象...
SSM之Spring中的JdbcTemplate/JdbcTemplate在IDEA中怎么用？/JdbcTemplate是啥
花花的小脑瓜的博客
11-23 920
写在前面： 接着记录自己的Spring学习之旅，若看不懂则建议先看前几篇博文，详细代码可在我的Gitee仓库ssm-learning克隆下载学习使用！ 1.10 JDBC Template 1.10.1 概述 JDBC Template是spring框架中提供的一个对象，是对原始复杂jdbc api的封装。一般提供对应多种数据库的操作模板类，主要有以下几种： 数据库类型 模板类 关系型数据库 Jdbc Template 和Hibernate Template noSql数据库 Redis
java之JdbcTemplate技术
Pxx520Tangtian的博客
03-25 2730
之前去连接一个数据库，我们注册驱动，得到连接对象，然后得到语句句柄，再来执行，这玩意有点麻烦，每次都要这样写一套，然后才能进行sql语句的查询和其他操作。 那么后来我们把连接对象与关闭对象这个工作给拿了出来，把需要里注册的数据库连接，用户名，密码，数据库名都放到一个properties的配置文件里面。 先来看这个配置文件utils.properties配置文件，这个文件直接放在了src目录下面 其实driver这个数据库驱动的注册完全可以省略，因为数据库管理接口在调用getConnection()
JDBC实战（九）JdbcTemplate浅学
LH is programming hard
08-09 1105
JdbcTemplate浅学 前面我们学习了有关JDBC的封装，如何让JDBC使用更加灵活。用到的技术手段简单应用有很多。现在小结如下： 利用反射，得到结果集的参数，从而实现查询更加灵活。 模板设计模式，只需要sql语句和占位符参数，可以实现不只一个ORM对象的增删改操作 策略模式，大大提高了增删改的功能差异修改 DAO、ORM 代理模式，实现了数据库连接池等操作，静态代理、动态代理（结合反射） 工厂模式 Apache的开源项目DBCP数据库连接池的使用 那么，上面的这些对JDBC的封装优化等，spri
spring_demo14——使用JdbcTemplate操作数据库--IDEA准备工作
weixin_44374666的博客
09-15 172
使用IDEA新建Java项目 1.引入相应的jar包
idea中maven的spring-boot-maven-plugin报红
10-30
当在IDEA中创建Spring Boot项目时，可能会出现spring-boot-maven-plugin报红的情况。这通常是由于缺少版本号或Maven仓库的问题导致的。解决这个问题的方法有两种： 1. 在IDEA的pom文件中插入版本号version 2.7.0即可...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值