jsp学习（十四,基于数据库学习spring）

I Am Rex

已于 2022-05-17 00:27:15 修改

阅读量226

点赞数

分类专栏： jsp 文章标签： spring 学习数据库

于 2022-05-17 00:14:29 首次发布

本文链接：https://blog.csdn.net/m0_49936845/article/details/124809492

版权

jsp 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

先看完教程，想着做项目去学的。

环境结构

idea：IntelliJ IDEA 2021.2.4
idea开发spring要比普通版本的eclipse方便的多，很多环境只需要设置即可
spring开发一般和maven搭配使用，maven可以自动拉取需要的库，方便开发

注意：一般maven设置的是国内镜像，虽然快，但是不全。所以可能拉取以后，有的属性会报错说没有找到，但一般这些属性也不会用，所以删除即可，具体入门改留哪些属性下面再说

创建项目

步骤
1.下载idea专业版 2021.2.4（2022版本不能pj，这里不讲pj）
2.下载maven3.6（高版本不支持喔）
3.打开idea，选择创建spring
在这里插入图片描述
一定注意java版本
4.选择插件

5.在设置里面搜索maven，添加自己下的maven的主路径和配置文件（安装maven还需要修改配置文件，具体搜索spring maven安装教程）
在这里插入图片描述
配置好以后如果是第一次配置，就会在右下角看到拉取的库

如果不出意外的话会出意外，打开pom.xml会看到很多错误，就是上面说库不全的原因
我们留下一下配置：（这是我基于mysql配置留下的属性喔，还有注意java版本一定配置对maven.compiler.source）

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo1</name>
    <description>demo1</description>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                    <classifier>${repackage.classifier}</classifier>
                    <image>
                        <builder>paketobuildpacks/builder:tiny</builder>
                        <env>
                            <BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
                        </env>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

我也不太看得懂，但是配置某样东西的时候一般有xml的说明

连接数据库

在这里插入图片描述

没有控制层，就一个dao，一个user，一个userservicel。

dao层为持久层，entity是实体，就是存数据的Javabean，service是业务层，负责处理数据，和mvc的控制器一样，也经常命名为Controller。
在这里插入图片描述

JdbcTemplate 是 Spring JDBC 核心包（core）中的核心类，它可以通过配置文件、注解、Java 配置类等形式获取数据库的相关信息，实现了对 JDBC 开发过程中的驱动加载、连接的开启和关闭、SQL 语句的创建与执行、异常处理、事务处理、数据类型转换等操作的封装。我们只要对其传入SQL 语句和必要的参数即可轻松进行 JDBC 编程。

实体：

package com.example.demo.entity;

public class User {
    private Integer userId;
    private String userName;
    private String status;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", status='" + status + '\'' +
                '}';
    }
}

dao层（接口不展示了）

package com.example.demo.dao.impl;

import com.example.demo.dao.UserDao;
import com.example.demo.entity.User;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.List;

@Repository
public class UserDaoImpl implements UserDao {
    @Resource
    private JdbcTemplate jdbcTemplate;
//    @Resource
//    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    @Override
    public int addUer(User user) {
        String sql = "INSERT into `user` (`user`.user_name,`user`.`status`) VALUES(?,?);";
        int update = jdbcTemplate.update(sql, user.getUserName(), user.getStatus());
        return update;
    }

    @Override
    public int update(User user) {
        String sql = "UPDATE `user` SET status=? WHERE user_name=?;";

        return jdbcTemplate.update(sql, user.getStatus(), user.getUserName());
    }

    @Override
    public int delete(User user) {
        String sql = "DELETE FROM `user` where user_name=?;";
        return jdbcTemplate.update(sql, user.getUserName());
    }

    @Override
    public int count(User user) {
        String sql = "SELECT COUNT(*) FROM `user` where `status`=?;";
        return jdbcTemplate.queryForObject(sql, Integer.class, user.getStatus());
    }


    @Override
    public List<User> getList(User user) {
        String sql = "SELECT * FROM `user` where `status`=?;";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class), user.getStatus());
    }

    @Override
    public User getUser(User user) {
        String sql = "SELECT * FROM `user` where `user_id`=?;";
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), user.getUserId());
    }

    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql = "INSERT into `user` (`user`.user_name,`user`.`status`) VALUES(?,?);";
        jdbcTemplate.batchUpdate(sql, batchArgs);
    }

}

业务层（其实这里也没做啥业务，主要是说明一下，这里可以做逻辑业务）：

package com.example.demo.service.impl;

import com.example.demo.dao.UserDao;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Resource
    private UserDao userDao;

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

    @Override
    public int updateUser(User user) {

        return userDao.update(user);
    }

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

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

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

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

    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        userDao.batchAddUser(batchArgs);
    }

//    @Override
//    public int countOfUserByName(User user) {
//        return userDao.countOfUserByName(user);
//    }
//
//    @Override
//    public User getUserByUserId(User user) {
//        return userDao.getUserByUserId(user);
//    }

}

主类：

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.ArrayList;
import java.util.List;


public class Demo1Application {

    public static void main(String[] args) {
        ApplicationContext context2 = new ClassPathXmlApplicationContext("Beans.xml");
        UserService userService = context2.getBean("userService", UserService.class);

        User user = new User();
        user.setUserName("小张");
        user.setStatus("离线");
        //新增一个用户
        int i = userService.addUser(user);
        System.out.println("新增用户成功！");

        User user1 = new User();
        user1.setUserName("小张");
        user1.setStatus("在线");
        int u = userService.updateUser(user1);
        System.out.println("修改用户成功");

        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"小明", "在线"};
        Object[] o2 = {"小龙", "离线"};
        Object[] o3 = {"小林", "在线"};
        Object[] o4 = {"小李", "在线"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        batchArgs.add(o4);
        userService.batchAddUser(batchArgs);
        System.out.println("批量增加完毕");

        User user2 = new User();
        user2.setStatus("在线");
        int i1 = userService.countUser(user2);
        System.out.println("在线用户的个数为：" + i1);

        List<User> userList = userService.getUserList(user2);
        System.out.println("在线用户列表查询成功！");
        for (User user4 : userList) {
            System.out.println("用户 ID:" + user4.getUserId() + "，用户名：" + user4.getUserName() + "，状态：" + user4.getStatus());
        }
    }
}

Beans.xml

```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-3.0.xsd
    http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.example.demo"></context:component-scan>
    <!--引入 jdbc.properties 中的配置-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!--定义数据源 Bean-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--数据库连接地址-->
        <property name="url" value="${jdbc.url}"/>
        <!--数据库的用户名-->
        <property name="username" value="${jdbc.username}"/>
        <!--数据库的密码-->
        <property name="password" value="${jdbc.password}"/>
        <!--数据库驱动-->
        <property name="driverClassName" value="${jdbc.driver}"/>
    </bean>

    <!--定义JdbcTemplate Bean-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--将数据源的 Bean 注入到 JdbcTemplate 中-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:// 192.168.101.121:3306/spring_jdbc_db
jdbc.username=root
jdbc.password=123

结果：
```bash
新增用户成功！
00:12:15.865 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL update
00:12:15.865 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [UPDATE `user` SET status=? WHERE user_name=?;]
00:12:15.865 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
00:12:15.865 [main] DEBUG org.springframework.jdbc.datasource.DriverManagerDataSource - Creating new JDBC DriverManager Connection to [jdbc:mysql:// 192.168.101.121:3306/spring_jdbc_db]
修改用户成功
00:12:15.883 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing SQL batch update [INSERT into `user` (`user`.user_name,`user`.`status`) VALUES(?,?);]
00:12:15.884 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [INSERT into `user` (`user`.user_name,`user`.`status`) VALUES(?,?);]
00:12:15.884 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
00:12:15.884 [main] DEBUG org.springframework.jdbc.datasource.DriverManagerDataSource - Creating new JDBC DriverManager Connection to [jdbc:mysql:// 192.168.101.121:3306/spring_jdbc_db]
00:12:15.900 [main] DEBUG org.springframework.jdbc.support.JdbcUtils - JDBC driver supports batch updates
批量增加完毕
00:12:15.919 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL query
00:12:15.920 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [SELECT COUNT(*) FROM `user` where `status`=?;]
00:12:15.920 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
00:12:15.920 [main] DEBUG org.springframework.jdbc.datasource.DriverManagerDataSource - Creating new JDBC DriverManager Connection to [jdbc:mysql:// 192.168.101.121:3306/spring_jdbc_db]
在线用户的个数为：12
00:12:15.972 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL query
00:12:15.972 [main] DEBUG org.springframework.jdbc.core.JdbcTemplate - Executing prepared SQL statement [SELECT * FROM `user` where `status`=?;]
00:12:15.972 [main] DEBUG org.springframework.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
00:12:15.972 [main] DEBUG org.springframework.jdbc.datasource.DriverManagerDataSource - Creating new JDBC DriverManager Connection to [jdbc:mysql:// 192.168.101.121:3306/spring_jdbc_db]
00:12:15.986 [main] DEBUG org.springframework.jdbc.core.BeanPropertyRowMapper - Mapping column 'user_id' to property 'userId' of type 'java.lang.Integer'
00:12:15.988 [main] DEBUG org.springframework.jdbc.core.BeanPropertyRowMapper - Mapping column 'user_name' to property 'userName' of type 'java.lang.String'
00:12:15.988 [main] DEBUG org.springframework.jdbc.core.BeanPropertyRowMapper - Mapping column 'status' to property 'status' of type 'java.lang.String'
在线用户列表查询成功！
用户 ID:6，用户名：小张，状态：在线
用户 ID:7，用户名：小明，状态：在线
用户 ID:9，用户名：小林，状态：在线
用户 ID:10，用户名：小李，状态：在线
用户 ID:11，用户名：小张，状态：在线
用户 ID:12，用户名：小明，状态：在线
用户 ID:14，用户名：小林，状态：在线
用户 ID:15，用户名：小李，状态：在线
用户 ID:16，用户名：小张，状态：在线
用户 ID:17，用户名：小明，状态：在线
用户 ID:19，用户名：小林，状态：在线
用户 ID:20，用户名：小李，状态：在线

进程已结束，退出代码为 0

这是没有配服务器的状态，所以采用的主类打印

下一节将学如何构建web目录和配置servlet

I Am Rex

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
jsp学习（十四,基于数据库学习spring）

目录环境结构创建项目连接数据库环境结构idea：IntelliJ IDEA 2021.2.4idea开发spring要比普通版本的eclipse方便的多，很多环境只需要设置即可spring开发一般和maven搭配使用，maven可以自动拉取需要的库，方便开发注意：一般maven设置的是国内镜像，虽然快，但是不全。所以可能拉取以后，有的属性会报错说没有找到，但一般这些属性也不会用，所以删除即可，具体入门改留哪些属性下面再说创建项目步骤1.下载idea专业版 2021.2.4（2022版本不
复制链接

扫一扫