java篇-(java使用内嵌Tomcat开发javaWeb项目-高级篇1)

最新推荐文章于 2024-04-12 11:00:59 发布
最新推荐文章于 2024-04-12 11:00:59 发布
阅读量1.1k 收藏 1
点赞数 2
分类专栏： java 文章标签： java spring jpa redis tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42413011/article/details/116545945
版权

java使用内嵌Tomcat开发javaWeb项目

写在前面

这一篇博客，是在java篇-(java使用内嵌Tomcat开发javaWeb项目-中级篇)这篇博客之上进行扩展,整合spring data jpa,junit,thymeleaf,redis实现使用此方式开发项目
项目初始结构请查看java篇-(java使用内嵌Tomcat开发javaWeb项目-中级篇这篇博客，博客地址: java篇-(java使用内嵌Tomcat开发javaWeb项目-中级篇)

整合spring data jpa

pom.xml添加spring data jpa相关依赖

在这里插入图片描述
这里只复制了jpa相关部分pom文件内容

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <kotlin.code.style>official</kotlin.code.style>
        <kotlin.compiler.jvmTarget>11</kotlin.compiler.jvmTarget>
        <tomcat.embed.version>9.0.31</tomcat.embed.version>
        <thymeleaf.version>3.0.12.RELEASE</thymeleaf.version>
        <spring.version>5.3.5</spring.version>
        <fastjson.version>1.2.73</fastjson.version>
        <validation-api.version>2.0.1.Final</validation-api.version>
        <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
        <javax.el-api.version>3.0.0</javax.el-api.version>
        <slf4j.version>1.7.30</slf4j.version>
        <log4j2.version>2.14.1</log4j2.version>
        <spring.data.version>2.4.7</spring.data.version>
        <hikaricp.version>4.0.3</hikaricp.version>
        <hibernate.version>5.4.15.Final</hibernate.version>
        <hibernate.jpa.version>1.0.2.Final</hibernate.jpa.version>
        <javax.persistence-api.version>2.2</javax.persistence-api.version>
        <mysql.version>8.0.23</mysql.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>${javax.persistence-api.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.1-api</artifactId>
            <version>${hibernate.jpa.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.zaxxer/HikariCP -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>${hikaricp.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>${spring.data.version}</version>
        </dependency>
        ...

添加spring data jpa相关配置

在resources目录下面创建spring-config.xml，用来加载配置文件

在这里插入图片描述

在spring-config.xml里面配置加载配置文件

spring-config.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 https://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:db.properties" />
</beans>

创建数据库配置文件

在这里插入图片描述

db.properties

db.username=root
db.password=123456
db.driverClassName=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://192.168.101.150:3306/embed-tomcat?allowPublicKeyRetrieval=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8&useUnicode=true
db.maxSize=5
db.maxLifetime=300000
db.minIdle=1

在resources目录下面创建spring-jpa.xml，用来存放jpa相关配置

在这里插入图片描述

在spring-jpa.xml添加jpa相关配置

spring-jpa.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:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/data/jpa https://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!--  扫描jpa repository 接口  -->
    <jpa:repositories base-package="com.lhstack.embed.repository" entity-manager-factory-ref="entityManagerFactoryBean"
                      transaction-manager-ref="transactionManager"/>
	<!--  开启事物注解驱动  -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
        <property name="jdbcUrl" value="${db.url}"/>
        <property name="driverClassName" value="${db.driverClassName}"/>
        <property name="minimumIdle" value="${db.minIdle}"/>
        <property name="maximumPoolSize" value="${db.maxSize}"/>
        <!--    单个链接的最大生命周期    -->
        <property name="maxLifetime" value="${db.maxLifetime}"/>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="dataSource" ref="dataSource"/>
        <property name="entityManagerFactory" ref="entityManagerFactoryBean"/>
    </bean>

    <bean id="entityManagerFactoryBean" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaProperties">
            <props>
                <!--        格式化jpa打印的sql语句        -->
                <prop key="hibernate.format_sql">true</prop>
            </props>
        </property>
        <!--    扫描jpa entity所在包里面的类，与数据库表进行绑定    -->
        <property name="packagesToScan" value="com.lhstack.embed.entity.domain"/>

        <property name="jpaVendorAdapter" ref="jpaVendorAdapter"/>
    </bean>

    <bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <!--    根据entity自动生成数据库表，同步    -->
        <property name="generateDdl" value="true"/>
        <property name="database" value="MYSQL"/>
        <!--    显示sql    -->
        <property name="showSql" value="true"/>
    </bean>
</beans>

创建entity

这里包就是上面jpa配置里面的entityManagerFactoryBean.packagesToScan所在的包
在这里插入图片描述
User.java

package com.lhstack.embed.entity.domain;

import javax.persistence.*;
import java.util.Date;

/**
 * @author lhstack
 * Entity 标识此对象是数据库里面的表
 * Table标识对应数据库那张表，这里对应的就是t_user这张表
 */
@Entity
@Table(name = "t_user")
public class User {

    /**
     * Id标识此字段为主键
     * GenerationType.IDENTITY是设置id自增
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "name",length = 20,nullable = false,unique = true)
    private String name;

    @Column(name = "username",length = 20,nullable = false,unique = true)
    private String username;

    @Column(name = "password",length = 200,nullable = false)
    private String password;

    @Column(name = "create_time",nullable = false)
    private Date createTime;

    @Column(name = "update_time",nullable = false)
    private Date updateTime;

    public User() {
    }

    public User(Integer id, String name, String username, String password, Date createTime, Date updateTime) {
        this.id = id;
        this.name = name;
        this.username = username;
        this.password = password;
        this.createTime = createTime;
        this.updateTime = updateTime;
    }

    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 getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", createTime=" + createTime +
                ", updateTime=" + updateTime +
                '}';
    }
}

创建对应的repository

同理，这里对应jpa:repositories标签里面的base-package属性值
在这里插入图片描述
UserRepository.java

package com.lhstack.embed.repository;

import com.lhstack.embed.entity.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User,Integer> {
}

在resources目录下面创建spring-service.xml配置文件,配置扫描service相关接口

在这里插入图片描述
spring-service.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 https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.lhstack.embed.service" />
</beans>

在配置的包下面创建对应的service接口和实现类

在这里插入图片描述
IUserService.java

package com.lhstack.embed.service;

import com.lhstack.embed.entity.domain.User;
import org.springframework.data.domain.Page;

import java.util.List;

/**
 * 用户相关接口
 * @author lhstack
 */
public interface IUserService {

    User save(User user);

    User update(Integer id,User user);

    List<User> queryList();

    Page<User> queryPageList(Integer page,Integer size);

    User findById(Integer id);

    void deleteById(Integer id);
}

UserServiceImpl.java

package com.lhstack.embed.service.impl;

import com.lhstack.embed.entity.domain.User;
import com.lhstack.embed.repository.UserRepository;
import com.lhstack.embed.service.IUserService;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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

/**
 * @author lhstack
 * 用户操作相关实现类
 */
@Service
public class UserServiceImpl implements IUserService {

    private final UserRepository userRepository;

    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class, RuntimeException.class})
    public User save(User user) {
        user.setCreateTime(new Date());
        user.setUpdateTime(new Date());
        return userRepository.save(user);
    }

    @Override
    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class, RuntimeException.class})
    public User update(Integer id, User user) {
        Optional<User> optionalUser = userRepository.findById(id);
        if (optionalUser.isPresent()) {
            User result = optionalUser.get();
            if (StringUtils.hasText(user.getName())) {
                result.setName(user.getName());
            }
            if (StringUtils.hasText(user.getUsername())) {
                result.setUsername(user.getUsername());
            }
            if (StringUtils.hasText(user.getPassword())) {
                result.setPassword(user.getPassword());
            }
            result.setUpdateTime(new Date());
            return userRepository.save(result);
        }
        return null;
    }

    @Override
    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    public List<User> queryList() {
        return userRepository.findAll();
    }

    @Override
    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    public Page<User> queryPageList(Integer page, Integer size) {
        return userRepository.findAll(PageRequest.of(page - 1, size));
    }

    @Override
    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    public User findById(Integer id) {
        return userRepository.findById(id).orElseGet(null);
    }

    @Override
    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class, RuntimeException.class})
    public void deleteById(Integer id) {
        userRepository.deleteById(id);
    }
}

创建UserController，暴露curd接口

在这里插入图片描述
UserController.java

package com.lhstack.embed.controller;

import com.lhstack.embed.entity.domain.User;
import com.lhstack.embed.service.IUserService;
import org.springframework.data.domain.Page;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("user")
public class UserController {

    private final IUserService userService;

    public UserController(IUserService userService) {
        this.userService = userService;
    }


    @PostMapping
    public User save(@RequestBody User user) {
        return userService.save(user);
    }

    @PutMapping("{id}")
    public User updateById(@PathVariable("id") Integer id, @RequestBody User user) {
        return userService.update(id, user);
    }

    @GetMapping("list")
    public List<User> queryList(){
        return userService.queryList();
    }

    @GetMapping("page")
    public Page<User> queryPageList(@RequestParam(name = "page",defaultValue = "1")Integer page,
                                    @RequestParam(name = "size",defaultValue = "10") Integer size){
        return userService.queryPageList(page,size);
    }

    @DeleteMapping("{id}")
    public ResponseEntity<Boolean> deleteById(@PathVariable("id") Integer id){
        userService.deleteById(id);
        return ResponseEntity.ok(true);
    }
}

启动项目

控制台打印了对应的sql，数据库自动创建了对应的表结构
在这里插入图片描述
在这里插入图片描述
使用postman测试接口
添加数据
在这里插入图片描述
更新数据
在这里插入图片描述
查询数据
在这里插入图片描述
分页查询
在这里插入图片描述
在这里插入图片描述

整合junit，实现单元测试

pom.xml添加junit相关依赖

在这里插入图片描述
这里只复制junit相关的内容
pom.xml

	...
    	<junit.version>4.12</junit.version>
    </properties>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    ...

创建test类，配置spring使用junit进行单元测试

在这里插入图片描述

执行单元测试

在这里插入图片描述

整合thymeleaf，实现mvc架构

在pom.xml添加thymeleaf相关依赖

由于之前在pom.xml里面预留了thymeleaf的依赖,所以这里添加thymeleaf集成spring的依赖即可
在这里插入图片描述

		<dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>${thymeleaf.version}</version>
        </dependency>

在resources目录创建spring-thymeleaf.xml文件

用于存放spring继承thymeleaf的配置信息
在这里插入图片描述
spring-thymeleaf.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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <bean id="springResourceTemplateResolver"
          class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
        <!--    开启缓存，并配置缓存时间    -->
        <property name="cacheTTLMs" value="60000"/>
        <property name="cacheable" value="true"/>
        <!--   配置前缀，这里会根据tomcat的docBase作为相对路径向下匹配     -->
        <property name="prefix" value="/templates/"/>
        <!--   后缀，这里根据controller返回的字符串，拼接为context.getRealPath() + prefix + controller return value + suffix     -->
        <property name="suffix" value=".html"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateMode" value="HTML5"/>
    </bean>

    <bean id="templateEngine" class="org.thymeleaf.spring5.SpringTemplateEngine">
        <property name="templateResolver" ref="springResourceTemplateResolver"/>
        <!--   配置支持spring el表达式     -->
        <property name="enableSpringELCompiler" value="true"/>
    </bean>

    <bean class="org.thymeleaf.spring5.view.ThymeleafViewResolver" id="viewResolver">
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine" ref="templateEngine"/>
        <!--   设置响应给浏览器的内容格式     -->
        <property name="contentType" value="text/html;charset=utf-8"/>
    </bean>

    <!--  配置视图解析器  -->
    <mvc:view-resolvers>
        <ref bean="viewResolver"/>
    </mvc:view-resolvers>

</beans>

编写controller进行测试

在这里插入图片描述
IndexController.kt

package com.lhstack.embed.controller

import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping

@Controller
@RequestMapping("index")
class IndexController {

    @GetMapping
    fun index():String{
        return "index"
    }
}

在resources目录下面创建对应的html页面
在这里插入图片描述

启动项目，访问index

在这里插入图片描述

结合spring data jpa，实现简单的crud

修改IndexController,添加crud相关逻辑

在这里插入图片描述

IndexController.kt

package com.lhstack.embed.controller

import com.lhstack.embed.entity.domain.User
import com.lhstack.embed.service.IUserService
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation.*
import java.util.*

@Controller
@RequestMapping("thymeleaf")
class IndexController(private val userService: IUserService) {

    @GetMapping("index")
    fun index(model: Model,
              @RequestParam(name = "page",defaultValue = "1") page: Int,
              @RequestParam(name = "size",defaultValue = "10")size: Int
    ):String{
        model.addAttribute("list",this.userService.queryPageList(page,size))
        return "index"
    }


    /**
     * 跳转更新页面
     */
    @GetMapping("toUpdatePage/{id}")
    fun toUpdatePage(model:Model,@PathVariable("id") id:Int):String{
        val user = this.userService.findById(id)
        if(Objects.isNull(user)){
            return "redirect:/thymeleaf/index"
        }
        model.addAttribute("user",user)
        return "update"
    }

    @PostMapping("update/{id}")
    fun update(user:User,@PathVariable("id") id:Int):String{
        this.userService.update(id,user)
        return "redirect:/thymeleaf/index"
    }

    /**
     * 跳转保存页面
     */
    @GetMapping("toSave")
    fun toSavePage():String{
        return "save"
    }

    @PostMapping("save")
    fun save(user:User):String{
        this.userService.save(user)
        return "redirect:/thymeleaf/index"
    }

    @GetMapping("del/{id}")
    fun delete(@PathVariable("id") id:Int):String{
        this.userService.deleteById(id)
        return "redirect:/thymeleaf/index"
    }
}

修改index.html，实现渲染用户列表

在这里插入图片描述
index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="https://www.thymeleaf.org/">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
<a th:href="${#request.contextPath} + '/thymeleaf/toSave'">新增</a>
<table>
    <thead>
        <tr>
            <th>id</th>
            <th>名称</th>
            <th>用户名</th>
            <th>密码</th>
            <th>操作</th>
        </tr>
    </thead>
    <tbody>
        <tr th:each="item,stat : ${list}">
            <td th:text="${item.id}"></td>
            <td th:text="${item.name}"></td>
            <td th:text="${item.username}"></td>
            <td th:text="${item.password}"></td>
            <td>
                <a th:href="${#request.getContextPath()} + '/thymeleaf/toUpdatePage/' + ${item.id}">更新</a>
                <a th:href="${#request.getContextPath()} + '/thymeleaf/del/' + ${item.id}">删除</a>
            </td>
        </tr>
    </tbody>
</table>
<a th:href="${#request.getContextPath()} + '/thymeleaf/index?page=1&size=' + ${list.pageable.pageSize}">首页</a>
<a th:href="${#request.getContextPath()} + '/thymeleaf/index?page=' + ${list.pageable.pageNumber <= 0 ? 1 : list.pageable.pageNumber} + '&size=' + ${list.pageable.pageSize}">上一页</a>
<a th:href="${#request.getContextPath()} + '/thymeleaf/index?page=' + ${list.pageable.pageNumber + 2} + '&size=' + ${list.pageable.pageSize}">下一页</a>
</body>
</html>

添加新增页面，实现数据的新增

在这里插入图片描述

save.html

<!DOCTYPE html>
<html lang="en" xmlns:th="https://www.thymeleaf.org/">
<head>
    <meta charset="UTF-8">
    <title>update</title>
</head>
<body>
<form th:action="${#request.contextPath} + '/thymeleaf/save/'" method="post">
    <div>
        <label for="name">名称</label>
        <input name="name" id="name"/>
    </div>
    <div>
        <label for="username">用户名</label>
        <input name="username" id="username" />
    </div>
    <div>
        <label for="password">密码</label>
        <input name="password" id="password" />
    </div>
    <div>
        <input type="submit" value="提交" /><input type="reset" value="重置" />
    </div>
</form>
</body>
</html>

添加更新页面，实现数据更新

在这里插入图片描述

update.html

<!DOCTYPE html>
<html lang="en" xmlns:th="https://www.thymeleaf.org/">
<head>
    <meta charset="UTF-8">
    <title>update</title>
</head>
<body>
<form th:action="${#request.contextPath} + '/thymeleaf/update/' + ${user.id}" method="post">
    <div>
        <label for="name">名称</label>
        <input name="name" id="name" th:value="${user.name}" />
    </div>
    <div>
        <label for="username">用户名</label>
        <input name="username" id="username" th:value="${user.username}" />
    </div>
    <div>
        <label for="password">密码</label>
        <input name="password" id="password" th:value="${user.password}" />
    </div>
    <div>
        <input type="submit" value="提交" /><input type="reset" value="重置" />
    </div>
</form>
</body>
</html>

启动项目

访问首页
在这里插入图片描述
新增数据
在这里插入图片描述
在这里插入图片描述
修改数据
在这里插入图片描述
在这里插入图片描述
删除数据
在这里插入图片描述
在这里插入图片描述

添加redis，实现数据的缓存

pom.xml添加spring-data-redis和redis客户端相关依赖

在这里插入图片描述

	...
	<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <kotlin.code.style>official</kotlin.code.style>
        <kotlin.compiler.jvmTarget>11</kotlin.compiler.jvmTarget>
        <tomcat.embed.version>9.0.31</tomcat.embed.version>
        <thymeleaf.version>3.0.12.RELEASE</thymeleaf.version>
        <spring.version>5.3.5</spring.version>
        <fastjson.version>1.2.73</fastjson.version>
        <validation-api.version>2.0.1.Final</validation-api.version>
        <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
        <javax.el-api.version>3.0.0</javax.el-api.version>
        <slf4j.version>1.7.30</slf4j.version>
        <log4j2.version>2.14.1</log4j2.version>
        <spring.data.version>2.4.7</spring.data.version>
        <hikaricp.version>4.0.3</hikaricp.version>
        <hibernate.version>5.4.15.Final</hibernate.version>
        <hibernate.jpa.version>1.0.2.Final</hibernate.jpa.version>
        <javax.persistence-api.version>2.2</javax.persistence-api.version>
        <mysql.version>8.0.23</mysql.version>
        <junit.version>4.12</junit.version>
        <lettuct.version>6.1.0.RELEASE</lettuct.version>
    </properties>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/io.lettuce/lettuce-core -->
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>${lettuct.version}</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>${spring.data.version}</version>
        </dependency>
    ...

修改spring-config.xml，加载redis配置文件

在这里插入图片描述
redis.propertis
在这里插入图片描述redis.properties

redis.database=0
redis.host=192.168.101.150
redis.port=6379

resources目录下创建spring-redis.xml配置文件

在这里插入图片描述
spring-redis.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:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">

    <bean id="redisConnectionFactory"
          class="org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory">
        <constructor-arg index="0" ref="standaloneConfiguration"/>
    </bean>
    <bean id="standaloneConfiguration" class="org.springframework.data.redis.connection.RedisStandaloneConfiguration">
        <property name="database" value="${redis.database}"/>
        <property name="port" value="${redis.port}"/>
        <property name="hostName" value="${redis.host}"/>
    </bean>

    <bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager" factory-method="create">
        <constructor-arg ref="redisConnectionFactory"/>
    </bean>

    <!--  后续可能会用到调redis api的地方 ，这里先创建出redisTemplate -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisConnectionFactory"/>
    </bean>

    <!--  开启缓存，并使用redis作为cache组件  -->
    <cache:annotation-driven cache-manager="cacheManager"/>
</beans>

修改UserServiceImpl里面的方法，加入缓存功能

在这里插入图片描述

UserServiceImpl.java

package com.lhstack.embed.service.impl;

import com.lhstack.embed.entity.domain.User;
import com.lhstack.embed.repository.UserRepository;
import com.lhstack.embed.service.IUserService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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

/**
 * @author lhstack
 * 用户操作相关实现类
 */
@Service
public class UserServiceImpl implements IUserService {

    private final UserRepository userRepository;

    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    /**
     * @CacheEvict(cacheNames = "user",allEntries = true)清除cacheName为user的所有缓存
     * @param user
     * @return
     */
    @Override
    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class, RuntimeException.class})
    @CacheEvict(cacheNames = "user",allEntries = true)
    public User save(User user) {
        user.setCreateTime(new Date());
        user.setUpdateTime(new Date());
        return userRepository.save(user);
    }

    @CacheEvict(cacheNames = "user",allEntries = true)
    @Override
    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class, RuntimeException.class})
    public User update(Integer id, User user) {
        Optional<User> optionalUser = userRepository.findById(id);
        if (optionalUser.isPresent()) {
            User result = optionalUser.get();
            if (StringUtils.hasText(user.getName())) {
                result.setName(user.getName());
            }
            if (StringUtils.hasText(user.getUsername())) {
                result.setUsername(user.getUsername());
            }
            if (StringUtils.hasText(user.getPassword())) {
                result.setPassword(user.getPassword());
            }
            result.setUpdateTime(new Date());
            return userRepository.save(result);
        }
        return null;
    }

    @Cacheable(cacheNames = "user",key = "'queryList'")
    @Override
    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    public List<User> queryList() {
        return userRepository.findAll();
    }

    @Override
    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    @Cacheable(cacheNames = "user",key = "'queryPageList page:::' + #p0 + '  size:::' + #p1")
    public Page<User> queryPageList(Integer page, Integer size) {
        return userRepository.findAll(PageRequest.of(page - 1, size));
    }

    @Override
    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    @Cacheable(cacheNames = "user",key = "'findById id:::' + #p0")
    public User findById(Integer id) {
        return userRepository.findById(id).orElseGet(null);
    }

    @Override
    @Transactional(readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = {Exception.class, RuntimeException.class})
    @CacheEvict(cacheNames = "user",allEntries = true)
    public void deleteById(Integer id) {
        userRepository.deleteById(id);
    }
}

修改User.java类，让其实现Serializable接口，保证此对象可以被序列化

在这里插入图片描述

启动项目

第一次请求，控制台打印出了sql
在这里插入图片描述

在这里插入图片描述
第二次请求,还是第一次请求的sql，说明这一次没有走数据库
在这里插入图片描述
查看redis,缓存已经进来了
在这里插入图片描述
添加数据,控制台走了两次sql，第一次是插入数据，第二次是重定向到index时，查询数据，说明缓存是成功更新了的
在这里插入图片描述

在这里插入图片描述

小小白鸽
关注
专栏目录
Tomcat部署Web项目
qq_41941900的博客
06-28 1672
要使用这一方法部署未打包的webapp目录，只要把我们的项目（编译好的发布项目，非开发项目）放到Tomcat的webapps目录下就可以了。但这个时候，我们发现，在访问我们的项目内容时，必须加上我们的项目名字"myweb"，这样很不好。当我们启动Tomcat的时候，Tomcat要做的第一件事就是解包war文件的内容到相同文件名的路径中，取出.war扩展名，然后从解包的目录中读取项目文件。这个时候，我们再看一下Manager App页面的变化，如下图中圈中的部分，多了我们刚才发布的myweb项目。
内嵌式tomcat启动web工程
11-27
内嵌式tomcat启动web工程，maven代码 内嵌式tomcat启动web工程，maven代码
java篇-(java使用内嵌Tomcat开发javaWeb项目-进阶篇)
qq_42413011的博客
05-13 1581
java使用内嵌Tomcat开发javaWeb项目写在前面集成Swagger，实现优雅记录日志在pom.xml添加swagger依赖创建swagger配置类在spring-config.xml中配置扫描在controller下面创建ApiController，用于测试接口描述在spring-mvc.xml和spring-shiro.xml中开启swagger资源映射和关闭权限拦截 写在前面 这一篇博客，主要讲解项目开发中，接口文档编写，日志记录，项目部署, java使用内嵌Tomcat开发javaWeb项目
JAVA内嵌的tomcat服务器
最新发布
lf_1234的博客
04-12 228
在springboot web开发过程中，已经将tomcat集成进来了。启动springboot过程中，自动将内部tomcat启动。以后开发基本使用的都是内置的tomcat服务器。是内嵌的tomcat服务器。
Java嵌入式tomcat整合SpringMVC
qq_45794943的博客
12-02 1211
前言： 本文将介绍如何使用Java的方式启动tomcat，并整合Spring MVC，做到就像Springboot使用main方法启动，就可以访问controller资源的效果； 首先导入依赖： <properties> <embed.tomcat.version>9.0.21</embed.tomcat.version> </properties> <dependencies> <dep
将Tomcat嵌入到自己的应用中
顾传龙
04-16 1928
转自：http://yshjava.iteye.com/blog/1871965
java项目内嵌Tomcat
fygkchina的专栏
08-24 2948
这里是maven搭建的项目，如有所需可以自行到maven仓库下载，按照自己的实际情况选择tomcat版本。 一、maven依赖 dependencies> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-core</artifactId> <version&g...
javaweb——嵌入tomcat
guduyishuai的博客
02-14 3938
原创文章，转载请注明出处               该嵌入tomcat的实现可以直接运行类来启动tomcat，也可以在任意路径下运行bat文件启动tomcat，先看一下效果               开发过程，只需要运行类即可                             发布过程，只需把war放在bin文件加下，配置的mode项改为release，运行bat文件即可
《Java Web程序设计任务教程》-章节习题.docx 第1章网页开发基础 2.Java Web概述等
04-16
【Java Web程序设计任务教程】第1章主要涵盖了网页开发的基础知识。HTML是Hyper Text Markup Language的缩写，用于创建网页结构。`<body>`标签定义了HTML文档的主体内容，也就是网页上用户可见的部分。在HTML表格中...
embed-tomcat-example.zip
05-13
【描述】"java使用内嵌Tomcat开发javaWeb项目源代码"表明这个项目使用Java语言，通过内嵌Tomcat容器来运行和测试Java Web应用程序。内嵌Tomcat意味着Tomcat服务器是作为项目的一部分直接集成的，而不是作为一个独立...
JavaWeb项目源码-体育竞赛成绩管理系统-毕业设计论文-演讲汇报PPT.zip
03-20
在本系统中，SpringBoot负责整体架构，提供自动配置、内嵌Tomcat服务器等功能，降低了项目的复杂度。 2. **JSP技术**：JavaServer Pages（JSP）是一种动态网页技术，它允许将HTML代码与Java代码混合编写。在本项目...
Java内嵌式Tomcat-TomcatDemo
12-12
这是一个Java内嵌式 Tomcat的Demo。详细文章请见我的博客
狂神JAVA-18-SpringBoot学习1
08-04
- **Spring的简化**：随着Spring的发展，Spring Boot应运而生，它内嵌了Tomcat，使得我们可以直接打成jar包运行，进一步简化了部署过程。 - **微服务**：随着服务数量的增加，Spring Cloud被引入，作为微服务的...
java篇-(java使用内嵌Tomcat开发javaWeb项目-中级篇)
qq_42413011的博客
04-30 2269
java使用内嵌tomcat开发web项目写在前面在pom.xml里面加入spring相关依赖编写spring相关配置及代码java语言添加spring的DispatcherServlet,并在main方法里面调用添加spring-mvc.xml根据配置文件，创建对应测试文件启动项目,通过浏览器访问使用kotlin语言添加DispatcherServlet启动项目，使用浏览器访问添加json序列化支持pom文件里面添加fastjson依赖在配置文件里面添加fastjson序列化支持在controller添加
java内置tomcat_SpringBoot内置tomcat启动原理
weixin_35294082的博客
02-27 344
前言不得不说SpringBoot的开发者是在为大众程序猿谋福利，把大家都惯成了懒汉，xml不配置了，连tomcat也懒的配置了，典型的一键启动系统，那么tomcat在springboot是怎么启动的呢？内置tomcat开发阶段对我们来说使用内置的tomcat是非常够用了，当然也可以使用jetty。org.springframework.bootspring-boot-starter-web2.1....
Java应用程序中内嵌Tomcat启动
iteye_20333的博客
05-25 313
参考：http://tomcat.apache.org/tomcat-5.5-doc/catalina/docs/api/org/apache/catalina/startup/Embedded.html 有时候对于Tomcat的使用，需要内嵌在自己的应用程序中，由应用程序来控制Tomcat服务的启动、关闭等。这时，就可以通过Tomcat的startup包中提供的Embedded类来将Tomca...
嵌入式Tomcat的使用(即使用java代码控制tomcat服务)
Pazza_Infer的专栏
11-25 1万+
好长时间没有写文章了，有点懈怠了...最近在为公司开发Eclipse插件，需要有用到嵌入式Tomcat的地方，所以上网查找资料研究了一下。     开始时是想用Runtime.exec方法来操作普通tomcat中的startup.bat和shutdown.bat文件来达到启动关闭的效果,但是一直未能解决隐藏其dos窗口,后来有感于MyEclipse自带的Tomcat插件,我把它的插件取出来观察,
Tomcat部署网站Web项目（一）·内嵌
热门推荐
两行代码 踏踏实实de工作
08-22 4万+
Tomcat部署网站Web项目（一）下载文件解压html文件Tomcat放置html访问Html效果预览 下载文件 首先需要一个网页（html），我已经写好了，你可以直接下载》》点击下载 解压html文件 Tomcat放置html 在Tomcat目录下webapps文件夹新建文件夹 wwwroot 然后在wwwroot文件夹下放置你下载解压后的html文件（index.html） 这是一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值