这里续写上一章博客（115章博客）
SpringBoot视图技术：
<! DOCTYPE html > < htmllang = " en" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < linkrel = " stylesheet" type = " text/css" media = " all" href = " ../../css/gtvg.css" th: href= " @{/css/gtvg.css}" /> < title> </ title> </ head> < body> < pth: text= " ${hello}" > </ p> </ body> </ html>
< pth: text= " ${title}" > </ p> Object title = model. getAttribute ( "title" ) ;
System . out. println ( title) ;
The locale country is: < spanth: text= " ${#locale.country}" > </ span> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency>
<?xml version="1.0" encoding="UTF-8"?>
< projectxmlns = " 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 http://maven.apache.org/xsd/maven-4.0.0.xsd" > < modelVersion> </ modelVersion> < parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < relativePath/> </ parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < properties> < maven.compiler.source> </ maven.compiler.source> < maven.compiler.target> </ maven.compiler.target> </ properties> < dependencies> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> </ dependencies> < build> < plugins> < plugin> < groupId> </ groupId> < artifactId> </ artifactId> </ plugin> </ plugins> </ build> </ project> spring : thymeleaf : cache : true encoding : UTF- 8 mode : HTML5 prefix : classpath: /templates/ suffix : .html
function sum ( a, b ) { return a+ b;
}
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> package com. controller ; import org. springframework. stereotype. Controller ;
import org. springframework. ui. Model ;
import org. springframework. web. bind. annotation. RequestMapping ; import java. util. Calendar ; @Controller
public class LoginController { @RequestMapping ( "/toLoginPage" ) public String toLoginPage ( Model model) { model. addAttribute ( "currentYear" , Calendar . getInstance ( ) . get ( Calendar . YEAR ) ) ; return "login" ; }
}
<! DOCTYPE html > < htmllang = " en" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < linkrel = " stylesheet" type = " text/css" media = " all" href = " ../../css/gtvg.css" th: href= " @{/css/gtvg.css}" /> < title> </ title> </ head> < body> < spanth: text= " ${#locale.country}" > </ span> < br> < spanth: text= " ${#locale.language}" > </ span> < br> < spanth: text= " ${currentYear}" > </ span> < br> < spanth: text= " ${currentYearr}" > </ span> < br> </ body> </ html>
< divth: object= " ${book}" > < p> < spanth: text= " *{title}" > </ span> </ p> </ div> package com. pojo ; public class book { private String title; public book ( ) { } public book ( String title) { this . title = title; } @Override public String toString ( ) { return "book{" + "title='" + title + '\'' + '}' ; } public String getTitle ( ) { return title; } public void setTitle ( String title) { this . title = title; }
} model. addAttribute ( "book" , new book ( "111" ) ) ;
login.tip=请登录
login.username=用户名
login.password=密码
login.rememberme=记住我
login.button=登录
login.tip=请登录
login.username=用户名
login.password=密码
login.rememberme=记住我
login.button=登录
login.tip=Please sign in
login.username=Username
login.password=Password
login.rememberme=Remember me
login.button=Login
spring : messages : basename : i18n.login
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> package com. con fig; import org. springframework. context. annotation. Bean ;
import org. springframework. context. annotation. Configuration ;
import org. springframework. lang. Nullable ;
import org. springframework. util. StringUtils ;
import org. springframework. web. servlet. LocaleResolver ; import javax. servlet. http. HttpServletRequest ;
import javax. servlet. http. HttpServletResponse ;
import java. util. Locale ; @Configuration
public class MyLocalResovel implements LocaleResolver { @Override public Locale resolveLocale ( HttpServletRequest httpServletRequest) { String l = httpServletRequest. getParameter ( "l" ) ; String header = httpServletRequest. getHeader ( "Accept-Language" ) ; Locale locale = null ; if ( ! StringUtils . isEmpty ( l) ) { String [ ] split = l. split ( "_" ) ; locale = new Locale ( split[ 0 ] , split[ 1 ] ) ; } else { String [ ] splits = header. split ( "," ) ; String [ ] split = splits[ 0 ] . split ( "-" ) ; locale = new Locale ( split[ 0 ] , split[ 1 ] ) ; } return locale; } @Override public void setLocale ( HttpServletRequest httpServletRequest, @Nullable HttpServletResponse httpServletResponse, @Nullable Locale locale) { } @Bean public LocaleResolver localeResolver ( ) { return new MyLocalResovel ( ) ; }
} package com. controller ; import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. stereotype. Controller ;
import org. springframework. web. bind. annotation. RequestMapping ;
import org. springframework. web. servlet. LocaleResolver ; import javax. servlet. http. HttpServletRequest ;
import javax. servlet. http. HttpServletResponse ;
import java. util. Locale ; @Controller
public class LoginController { @Autowired private LocaleResolver localeResolver; @RequestMapping ( "/toLoginPage" ) public String toLoginPage ( HttpServletRequest request, HttpServletResponse response) { Locale locale = localeResolver. resolveLocale ( request) ; response. setLocale ( locale) ; return "login" ; }
}
<! DOCTYPE html > < htmllang = " en" xmlns: th= " http://www.thymeleaf.org" > < head> < metacharset = " UTF-8" > < linkrel = " stylesheet" type = " text/css" media = " all" href = " ../../css/gtvg.css" th: href= " @{/css/gtvg.css}" /> < title> </ title> </ head> < body> < ath: href= " @{/toLoginPage(l='zh_CN')}" > </ a> < ath: href= " @{/toLoginPage(l='en_US')}" > </ a> </ body> </ html>
< buttonth: text= " #{login.button}" > < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> package com. pojo ; public class User { private String id; private String name; public User ( String id, String name) { this . id = id; this . name = name; } public String getId ( ) { return id; } public void setId ( String id) { this . id = id; } public String getName ( ) { return name; } public void setName ( String name) { this . name = name; } @Override public String toString ( ) { return "User{" + "id='" + id + '\'' + ", name='" + name + '\'' + '}' ; } } package com. service ; import com. pojo. User ;
import org. springframework. cache. annotation. Cacheable ;
import org. springframework. stereotype. Service ; @Service
public class UserService { @Cacheable ( value = "users" , key = "#user.id" ) public User getUserById ( User user) { System . out. println ( "Fetching user from database..." ) ; return user; } @Cacheable ( value = "users" , key = "#user.id" ) public User updateUser ( User user) { System . out. println ( "Updating user in database..." ) ; return user; }
} <?xml version="1.0" encoding="UTF-8"?>
< beansxmlns = " http://www.springframework.org/schema/beans" xmlns: xsi= " http://www.w3.org/2001/XMLSchema-instance" xmlns: context= " http://www.springframework.org/schema/context" xmlns: cache= " http://www.springframework.org/schema/cache" xsi: schemaLocation= " http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/cachehttp://www.springframework.org/schema/cache/spring-cache.xsd" > < context: component-scanbase-package = " com" /> < cache: annotation-drivencache-manager = " cacheManager" /> < beanid = " cacheManager" class = " org.springframework.cache.concurrent.ConcurrentMapCacheManager" > < constructor-argvalue = " users" /> </ bean> </ beans> package com ; import com. pojo. User ;
import com. service. UserService ;
import org. springframework. context. ApplicationContext ;
import org. springframework. context. support. ClassPathXmlApplicationContext ; public class MainTest { public static void main ( String [ ] args) { ApplicationContext context = new ClassPathXmlApplicationContext ( "spring.xml" ) ; UserService userService = context. getBean ( UserService . class ) ; User updatedUser1 = new User ( "1" , "Jane Doe" ) ; System . out. println ( userService. getUserById ( updatedUser1) ) ; System . out. println ( userService. getUserById ( updatedUser1) ) ; User updatedUser2 = new User ( "1" , "Jane Doee" ) ; User user = userService. updateUser ( updatedUser2) ; System . out. println ( 2 ) ; System . out. println ( user) ; System . out. println ( userService. getUserById ( updatedUser2) ) ; }
}
@Service
public class a { @Cacheable ( value = "users" , key = "#user.id" ) public User fa ( User user) { System . out. println ( 7 ) ; return null ; }
} a a = context. getBean ( a. class ) ; User u = new User ( "1" , "2" ) ; System . out. println ( 9 ) ; System . out. println ( a. fa ( u) ) ;
CREATE DATABASE springbootdata;
USE springbootdata;
DROP TABLE IF EXISTS t_article;
CREATE TABLE t_article ( id int ( 20 ) NOT NULL AUTO_INCREMENT COMMENT '文章id' , title varchar ( 200 ) DEFAULT NULL COMMENT '文章标题' , content longtext COMMENT '文章内容' , PRIMARY KEY ( id)
) ENGINE = InnoDB AUTO_INCREMENT = 2 DEFAULT CHARSET = utf8; INSERT INTO t_article VALUES ( '1' , 'Spring Boot基础入门' , '从入门到精通讲解...' ) ;
INSERT INTO t_article VALUES ( '2' , 'Spring Cloud基础入门' , '从入门到精通讲解...' ) ;
DROP TABLE IF EXISTS t_comment;
CREATE TABLE t_comment ( id int ( 20 ) NOT NULL AUTO_INCREMENT COMMENT '评论id' , content longtext COMMENT '评论内容' , author varchar ( 200 ) DEFAULT NULL COMMENT '评论作者' , a_id int ( 20 ) DEFAULT NULL COMMENT '关联的文章id' , PRIMARY KEY ( id)
) ENGINE = InnoDB AUTO_INCREMENT = 3 DEFAULT CHARSET = utf8; INSERT INTO t_comment VALUES ( '1' , '很全、很详细' , 'lucy' , '1' ) ;
INSERT INTO t_comment VALUES ( '2' , '赞一个' , 'tom' , '1' ) ;
INSERT INTO t_comment VALUES ( '3' , '很详细' , 'eric' , '1' ) ;
INSERT INTO t_comment VALUES ( '4' , '很好，非常详细' , '张三' , '1' ) ;
INSERT INTO t_comment VALUES ( '5' , '很不错' , '李四' , '2' ) ;
<?xml version="1.0" encoding="UTF-8"?>
< projectxmlns = " 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 http://maven.apache.org/xsd/maven-4.0.0.xsd" > < modelVersion> </ modelVersion> < parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < relativePath/> </ parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < properties> < maven.compiler.source> </ maven.compiler.source> < maven.compiler.target> </ maven.compiler.target> </ properties> < dependencies> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> </ dependencies> < build> < plugins> < plugin> < groupId> </ groupId> < artifactId> </ artifactId> </ plugin> </ plugins> </ build> </ project> 创建com.pojo包，然后创建Comment类：
package com. pojo ; import javax. persistence. * ;
@Entity ( name = "t_comment" )
public class Comment { @Id @GeneratedValue ( strategy = GenerationType . IDENTITY ) private Integer id; private String content; private String author; @Column ( name = "a_id" ) private Integer aId; public Integer getId ( ) { return id; } public void setId ( Integer id) { this . id = id; } public String getContent ( ) { return content; } public void setContent ( String content) { this . content = content; } public String getAuthor ( ) { return author; } public void setAuthor ( String author) { this . author = author; } public Integer getaId ( ) { return aId; } public void setaId ( Integer aId) { this . aId = aId; } @Override public String toString ( ) { return "Comment{" + "id=" + id + ", content='" + content + '\'' + ", author='" + author + '\'' + ", aId=" + aId + '}' ; }
} 然后在com包下创建mapper包，然后创建CommentRepository接口：
package com. mapper ; import com. pojo. Comment ;
import org. springframework. data. jpa. repository. JpaRepository ;
import org. springframework. data. jpa. repository. Modifying ;
import org. springframework. data. jpa. repository. Query ; import javax. transaction. Transactional ; public interface CommentRepository extends JpaRepository < Comment , Integer > { @Transactional @Modifying @Query ( "update t_comment c set c.author = ?1 where c.id=?2" ) public int updateComment ( String author, Integer id) ;
}
然后创建com.service包，继续创建CommentService类：
package com. service ; import com. mapper. CommentRepository ;
import com. pojo. Comment ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. stereotype. Service ; import java. util. Optional ; @Service
public class CommentService { @Autowired private CommentRepository commentRepository; public Comment findCommentById ( Integer id) { Optional < Comment > = commentRepository. findById ( id) ; if ( comment. isPresent ( ) ) { Comment comment1 = comment. get ( ) ; return comment1; } return null ; }
} 然后再com包下创建controller包，然后创建CommentController类：
package com. controller ; import com. pojo. Comment ;
import com. service. CommentService ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. web. bind. annotation. RequestMapping ;
import org. springframework. web. bind. annotation. RestController ; @RestController
public class CommentController { @Autowired private CommentService commentService; @RequestMapping ( value = "/findCommentById" ) public Comment findCommentById ( Integer id) { Comment comment = commentService. findCommentById ( id) ; return comment; }
}
spring : datasource : url : jdbc: mysql: //localhost: 3306/springbootdata? serverTimezone=UTCusername : rootpassword : 123456 jpa : show-sql : true
mybatis : configuration : map-underscore-to-camel-case : true
server : servlet : encoding : charset : UTF- 8
package com ; import org. springframework. boot. SpringApplication ;
import org. springframework. boot. autoconfigure. SpringBootApplication ; @SpringBootApplication
public class BootApplication { public static void main ( String [ ] args) { SpringApplication . run ( BootApplication . class , args) ; }
} 启动，访问http://localhost:8080/findCommentById?id=1，看看结果吧，然后修改或者补充CommentService：
public int updateComment ( Integer id) { int ss = commentRepository. updateComment ( "ss" , id) ; return ss; }
CommentController也进行补充：
@RequestMapping ( value = "/updateComment" ) public int updateComment ( Integer id) { int i = commentService. updateComment ( id) ; return i; }
启动，访问http://localhost:8080/updateComment?id=1，然后看数据库是否修改即可，去掉@Modifying注解，看看是否会报错：
我们继续访问http://localhost:8080/findCommentById?id=1，看看后端的打印的sql语句
package com ; import org. springframework. boot. SpringApplication ;
import org. springframework. boot. autoconfigure. SpringBootApplication ;
import org. springframework. cache. annotation. EnableCaching ; @SpringBootApplication
@EnableCaching
public class BootApplication { public static void main ( String [ ] args) { SpringApplication . run ( BootApplication . class , args) ; }
} < cache: annotation-drivencache-manager = " cacheManager" /> < beanid = " cacheManager" class = " org.springframework.cache.concurrent.ConcurrentMapCacheManager" > < constructor-argvalue = " users" /> </ bean> @Cacheable ( cacheNames = "comment" ) public Comment findCommentById ( Integer id) { Optional < Comment > = commentRepository. findById ( id) ; if ( comment. isPresent ( ) ) { Comment comment1 = comment. get ( ) ; return comment1; } return null ; } 上述代码中，在CommentService类中的findCommentById方法上添加了查询缓存注解@Cacheable，该注解的作用是将查询结果Comment存放在Spring Boot默认缓存中名称为comment 的名称空间（namespace）中，对应缓存唯一标识
启动，然后访问：http://localhost:8080/findCommentById?id=1，多次访问后发现只会操作一次sql，但是他们好像与普通的spring的缓存有一些区别，在前面操作spring时，需要配置一下对应的缓存名称，但是这里没有，为什么：如果使用 Spring Boot，Spring Boot 提供了自动配置功能，在大多数情况下，只要你在代码中使用了缓存注解（如 @Cacheable），Spring Boot 会自动配置一个默认的缓存管理器（通常是 ConcurrentMapCacheManager），而无需手动设置缓存名（通常可以设置名称为单纯指定的名称或者方法名称，只是底层继续判断操作罢了），再者，spring缓存本质是操作读取配置文件形成的，当然，也会给出配置类的形式来完成（一般是得到ConcurrentMapCacheManager），自然spring boot在自动配置时会处理到
按照Cache的名字查询出Cache缓存列表，每一个Cache缓存列表中存在多个k-v键值对，即键和缓存值，也就是一个key对应一个值，换句话说，一个缓存里面存在多个key-value，上面的操作就是从缓存中找到comment的对应缓存，而对应缓存是map，名称是key，值是value
package org. springframework. boot. autoconfigure. cache ; import java. util. List ;
import org. springframework. boot. autoconfigure. condition. ConditionalOnMissingBean ;
import org. springframework. cache. CacheManager ;
import org. springframework. cache. concurrent. ConcurrentMapCacheManager ;
import org. springframework. context. annotation. Bean ;
import org. springframework. context. annotation. Conditional ;
import org. springframework. context. annotation. Configuration ; @Configuration ( proxyBeanMethods = false
)
@ConditionalOnMissingBean ( { CacheManager . class } )
@Conditional ( { CacheCondition . class } )
class SimpleCacheConfiguration { SimpleCacheConfiguration ( ) { } @Bean ConcurrentMapCacheManager cacheManager ( CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers) { ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager ( ) ; List < String > = cacheProperties. getCacheNames ( ) ; if ( ! cacheNames. isEmpty ( ) ) { cacheManager. setCacheNames ( cacheNames) ; } return ( ConcurrentMapCacheManager ) cacheManagerCustomizers. customize ( cacheManager) ; }
} public class ConcurrentMapCacheManager implements CacheManager , BeanClassLoaderAware { private final ConcurrentMap < String , Cache > = new ConcurrentHashMap ( 16 ) ; @Nullable public Cache getCache ( String name) { Cache cache = ( Cache ) this . cacheMap. get ( name) ; if ( cache == null && this . dynamic) { synchronized ( this . cacheMap) { cache = ( Cache ) this . cacheMap. get ( name) ; if ( cache == null ) { cache = this . createConcurrentMapCache ( name) ; this . cacheMap. put ( name, cache) ; } } } return cache; } protected Cache createConcurrentMapCache ( String name) { SerializationDelegate actualSerialization = this . isStoreByValue ( ) ? this . serialization : null ; return new ConcurrentMapCache ( name, new ConcurrentHashMap ( 256 ) , this . isAllowNullValues ( ) , actualSerialization) ; }
} public class ConcurrentMapCache extends AbstractValueAdaptingCache {
}
public abstract class AbstractValueAdaptingCache implements Cache {
}
public interface ConcurrentMap < K , V > extends Map < K , V > {
}
public class ConcurrentHashMap < K , V > extends AbstractMap < K , V > implements ConcurrentMap < K , V > , Serializable { private static final long serialVersionUID = 7249069246763182397L ;
}
public class SimpleKeyGenerator implements KeyGenerator { public SimpleKeyGenerator ( ) { }
}
public class SimpleKey implements Serializable { public static final SimpleKey EMPTY = new SimpleKey ( new Object [ 0 ] ) ; private final Object [ ] params; private transient int hashCode; public SimpleKey ( Object . . . elements) { Assert . notNull ( elements, "Elements must not be null" ) ; this . params = ( Object [ ] ) elements. clone ( ) ; this . hashCode = Arrays . deepHashCode ( this . params) ; }
}
ConcurrentMapCacheManager 不提供这些高级特性<?xml version="1.0" encoding="UTF-8"?>
< projectxmlns = " 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 http://maven.apache.org/xsd/maven-4.0.0.xsd" > < modelVersion> </ modelVersion> < parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < relativePath/> </ parent> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> < properties> < maven.compiler.source> </ maven.compiler.source> < maven.compiler.target> </ maven.compiler.target> </ properties> < dependencies> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> </ dependencies> </ project> package com. pojo ; import org. springframework. data. redis. core. index. Indexed ; public class Address { @Indexed private String city; @Indexed private String country; public Address ( String city, String country) { this . city = city; this . country = country; } public Address ( ) { } public String getCity ( ) { return city; } public void setCity ( String city) { this . city = city; } public String getCountry ( ) { return country; } public void setCountry ( String country) { this . country = country; } @Override public String toString ( ) { return "Address{" + "city='" + city + '\'' + ", country='" + country + '\'' + '}' ; }
}
package com. pojo ; import org. springframework. data. redis. core. RedisHash ;
import org. springframework. data. redis. core. index. Indexed ; import javax. persistence. Id ; @RedisHash ( "persons" )
public class Person { @Id private String id; @Indexed private String firstname; @Indexed private String lastname; private Address address; public Person ( String id, String firstname, String lastname, Address address) { this . id = id; this . firstname = firstname; this . lastname = lastname; this . address = address; } public Person ( ) { } public String getId ( ) { return id; } public void setId ( String id) { this . id = id; } public String getFirstname ( ) { return firstname; } public void setFirstname ( String firstname) { this . firstname = firstname; } public String getLastname ( ) { return lastname; } public void setLastname ( String lastname) { this . lastname = lastname; } public Address getAddress ( ) { return address; } public void setAddress ( Address address) { this . address = address; } @Override public String toString ( ) { return "Person{" + "id='" + id + '\'' + ", firstname='" + firstname + '\'' + ", lastname='" + lastname + '\'' + ", address=" + address + '}' ; }
} package com. mapper ; import com. pojo. Person ;
import org. springframework. data. repository. CrudRepository ; import java. util. List ; public interface PersonRepository extends CrudRepository < Person , String > { List < Person > findByAddress_City ( String name) ;
}
package com ; import org. springframework. boot. SpringApplication ;
import org. springframework. boot. autoconfigure. SpringBootApplication ; @SpringBootApplication
public class BootApplication { public static void main ( String [ ] args) { SpringApplication . run ( BootApplication . class , args) ; }
} spring : redis : host : 192.168.136.128 port : 6379 package com. te ; import com. mapper. PersonRepository ;
import com. pojo. Address ;
import com. pojo. Person ;
import org. junit. jupiter. api. Test ;
import org. junit. runner. RunWith ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. boot. test. context. SpringBootTest ;
import org. springframework. test. context. junit4. SpringRunner ; @RunWith ( SpringRunner . class )
@SpringBootTest
class BootTest { @Autowired private PersonRepository repository; @Test public void savePerson ( ) { Person person = new Person ( ) ; person. setFirstname ( "张" ) ; person. setLastname ( "三" ) ; Address address = new Address ( ) ; address. setCity ( "北京" ) ; address. setCountry ( "中国" ) ; person. setAddress ( address) ; Person save = repository. save ( person) ; System . out. println ( save) ; System . out. println ( person== save) ; }
} < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> < dependency> < groupId> </ groupId> < artifactId> </ artifactId> < scope> </ scope> </ dependency> package com. pojo ; import javax. persistence. * ; @Entity ( name = "t_comment" )
public class Comment { @Id @GeneratedValue ( strategy = GenerationType . IDENTITY ) private Integer id; private String content; private String author; @Column ( name = "a_id" ) private Integer aId; public Integer getId ( ) { return id; } public void setId ( Integer id) { this . id = id; } public String getContent ( ) { return content; } public void setContent ( String content) { this . content = content; } public String getAuthor ( ) { return author; } public void setAuthor ( String author) { this . author = author; } public Integer getaId ( ) { return aId; } public void setaId ( Integer aId) { this . aId = aId; } @Override public String toString ( ) { return "Comment{" + "id=" + id + ", content='" + content + '\'' + ", author='" + author + '\'' + ", aId=" + aId + '}' ; }
} package com. mapper ; import com. pojo. Comment ;
import org. springframework. data. jpa. repository. JpaRepository ;
import org. springframework. data. jpa. repository. Modifying ;
import org. springframework. data. jpa. repository. Query ; import javax. transaction. Transactional ; public interface CommentRepository extends JpaRepository < Comment , Integer > { @Transactional @Modifying @Query ( "update t_comment c set c.author = ?1 where c.id=?2" ) public int updateComment ( String author, Integer id) ;
}
package com. service ; import com. mapper. CommentRepository ;
import com. pojo. Comment ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. cache. annotation. Cacheable ;
import org. springframework. stereotype. Service ; import java. util. Optional ; @Service
public class CommentService { @Autowired private CommentRepository commentRepository; public Comment findCommentById ( Integer id) { Optional < Comment > = commentRepository. findById ( id) ; if ( comment. isPresent ( ) ) { Comment comment1 = comment. get ( ) ; return comment1; } return null ; } } package com. controller ; import com. pojo. Comment ;
import com. service. CommentService ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. web. bind. annotation. RequestMapping ;
import org. springframework. web. bind. annotation. RestController ; @RestController
public class CommentController { @Autowired private CommentService commentService; @RequestMapping ( value = "/findCommentById" ) public Comment findCommentById ( Integer id) { Comment comment = commentService. findCommentById ( id) ; return comment; } } < dependency> < groupId> </ groupId> < artifactId> </ artifactId> </ dependency> 先启动，然后访问：http://localhost:8080/findCommentById?id=1，若出现数据，说明我们操作成功
对CommentService类中的方法进行修改，使用@Cacheable、@CachePut、@CacheEvict三个注解定制缓存管理，分别进行缓存存储、缓存更新和缓存删除的演示
操作后的CommentService：
package com. service ; import com. mapper. CommentRepository ;
import com. pojo. Comment ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. cache. annotation. Cacheable ;
import org. springframework. stereotype. Service ; import java. util. Optional ; @Service
public class CommentService { @Autowired private CommentRepository commentRepository; @Cacheable ( cacheNames = "comment" , unless = "#result==null" ) public Comment findCommentById ( Integer id) { Optional < Comment > = commentRepository. findById ( id) ; if ( comment. isPresent ( ) ) { Comment comment1 = comment. get ( ) ; return comment1; } return null ; } } 继续补充CommentService：
@CachePut ( cacheNames = "comment" , key = "#result.id" ) public Comment updateComment ( Comment comment) { commentRepository. updateComment ( comment. getAuthor ( ) , comment. getaId ( ) ) ; return comment; } 对应的CommentController里面补充如下：
@RequestMapping ( value = "/updateComment" ) public Comment updateComment ( String str, Integer id) { Comment comment = new Comment ( ) ; comment. setAuthor ( str) ; comment. setId ( id) ; return commentService. updateComment ( comment) ; } 由于上面操作了类的缓存保存，一般来说，中间件操作类时基本会考虑序列化，而大多数序列化，通常需要类实现接口Serializable（自定义的序列化，通常是不需要的），所以我们给要操作的类，也就是Comment实现这个接口
http://localhost:8080/findCommentById?id=1，http://localhost:8080/findCommentById?id=123，当然，前提是启动redis，还有，有些中间件只有在执行对应代码时才会操作连接，否则不会，而redis也是如此，所以访问时操作缓存会连接redis，如果没有，那么访问上面的url就会报错，当然可能也不会报错，因为并非都会进行报错的处理，还有，报错也并非一定结束后续执行，比如报错信息只是打印的（catch的处理）
我们继续访问：http://localhost:8080/updateComment?id=1&str=ff，sql打印了，然后访问http://localhost:8080/findCommentById?id=1，是修改后的值，并且没有sql打印，因为放入了缓存，这个时候还是继续访问http://localhost:8080/updateComment?id=1&str=fg，sql打印了（因为修改是需要先执行的），其缓存值又是修改后的值了，继续访问http://localhost:8080/findCommentById?id=1，sql没有打印，得到的是修改后的值
至此，测试完毕，我们继续在CommentController中和CommentService中补充：
@CacheEvict ( cacheNames = "comment" ) public void deleteComment ( int comment_id) { commentRepository. deleteById ( comment_id) ; }
@RequestMapping ( value = "/deleteComment" ) public void deleteComment ( Integer id) { commentService. deleteComment ( id) ; }
启动后，访问http://localhost:8080/findCommentById?id=1，打印了sql，再访问http://localhost:8080/deleteComment?id=1，打印了sql，继续访问http://localhost:8080/findCommentById?id=1，发现还需要打印了，因为删除了缓存
但是还要注意一点：由于缓存是放在redis里面的，也就是说，重启spring boot，对应的缓存还是存在（而不是像默认的缓存管理重启就不在了，因为默认的是放在jvm的，重启的话，jvm自然也重启了），所以上面的操作可以建议先访问http://localhost:8080/deleteComment?id=1
首先我们清空redis数据，访问http://localhost:8080/findCommentById?id=2（前面已经删除数据了，所以id=2），当然了CacheEvict对应的方法也可以不操作删除，他只是对缓存删除处理而已，具体测试数据可以不进行删除的
执行上面方法查询出的用户评论信息Comment正确存储到了Redis缓存库中，其中"comment（cacheNames的值）"是缓存的名称空间下，缓存数据的唯一标识key值是以"缓存名称空间::参数值（comment::2）"的字符串形式体现的，而value值则是经过JDK默认序列格式化后的HEX格式存储（或者说是默认操作到redis的序列化，而默认操作的序列化则是jdk造成的序列化，这种操作编码或者序列化经过一系列处理后，变成上面的情况），这种JDK默认序列格式化后的数据显然不方便缓存数据的可视化查看和管理，所以在实际开发中，通常会自定义数据的序列化格式，前面我们就已经自定义了
spring : cache : redis.time-to-live : 10000
那么我们再service包下创建一个ApiCommentService类：
package com. service ; import com. mapper. CommentRepository ;
import com. pojo. Comment ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. data. redis. core. RedisTemplate ;
import org. springframework. stereotype. Service ; import java. util. Optional ;
import java. util. concurrent. TimeUnit ; @Service
public class ApiCommentService { @Autowired private CommentRepository commentRepository; @Autowired private RedisTemplate redisTemplate; public Comment findCommentById ( Integer id) { Object o = redisTemplate. opsForValue ( ) . get ( "comment_" + id) ; if ( o != null ) { return ( Comment ) o; } else { Optional < Comment > = commentRepository. findById ( id) ; if ( byId. isPresent ( ) ) { Comment comment = byId. get ( ) ; redisTemplate. opsForValue ( ) . set ( "comment_" + id, comment, 1 , TimeUnit . DAYS ) ; return comment; } else { return null ; } } } public Comment updateComment ( Comment comment) { commentRepository. updateComment ( comment. getAuthor ( ) , comment. getaId ( ) ) ; redisTemplate. opsForValue ( ) . set ( "comment_" + comment. getId ( ) , comment) ; return comment; } public void deleteComment ( int comment_id) { commentRepository. deleteById ( comment_id) ; redisTemplate. delete ( "comment_" + comment_id) ; }
}
在controller包下创建ApiCommentController类：
package com. controller ; import com. pojo. Comment ;
import com. service. ApiCommentService ;
import org. springframework. beans. factory. annotation. Autowired ;
import org. springframework. web. bind. annotation. RequestMapping ;
import org. springframework. web. bind. annotation. RestController ; @RestController
@RequestMapping ( "api" )
public class ApiCommentController { @Autowired private ApiCommentService commentService; @RequestMapping ( value = "/findCommentById" ) public Comment findCommentById ( Integer id) { Comment comment = commentService. findCommentById ( id) ; return comment; } @RequestMapping ( value = "/updateComment" ) public Comment updateComment ( String str, Integer id) { Comment comment = new Comment ( ) ; comment. setAuthor ( str) ; comment. setId ( id) ; return commentService. updateComment ( comment) ; } @RequestMapping ( value = "/deleteComment" ) public void deleteComment ( int id) { commentService. deleteComment ( id) ; }
} http://localhost:8080/api/findCommentById?id=2，http://localhost:8080/api/findCommentById?id=123，访问第一个，打印sql，继续访问则没有，第二个一直访问都会有sql打印（因为没有缓存）
清空redis数据库，我们继续访问：http://localhost:8080/api/updateComment?id=2&str=ff，sql打印了，然后访问http://localhost:8080/api/findCommentById?id=2，是修改后的值，并且没有sql打印，因为放入了缓存，这个时候还是继续访问http://localhost:8080/api/updateComment?id=2&str=fg，sql打印了（因为修改是需要先执行的），其缓存值又是修改后的值了，继续访问http://localhost:8080/api/findCommentById?id=2，sql没有打印，得到的是修改后的值
清空redis数据库，访问http://localhost:8080/api/findCommentById?id=2，打印了sql，再访问http://localhost:8080/api/deleteComment?id=2，打印了sql，继续访问http://localhost:8080/api/findCommentById?id=2，发现还需要打印了，因为删除了缓存
以访问http://localhost:8080/findCommentById?id=3和http://localhost:8080/api/findCommentById?id=3为例子：
public class RedisTemplate < K , V > extends RedisAccessor implements RedisOperations < K , V > , BeanClassLoaderAware { @Nullable private RedisSerializer keySerializer = null ; @Nullable private RedisSerializer valueSerializer = null ; public void afterPropertiesSet ( ) { super . afterPropertiesSet ( ) ; boolean defaultUsed = false ; if ( this . defaultSerializer == null ) { this . defaultSerializer = new JdkSerializationRedisSerializer ( this . classLoader != null ? this . classLoader : this . getClass ( ) . getClassLoader ( ) ) ; } if ( this . enableDefaultSerializer) { if ( this . keySerializer == null ) { this . keySerializer = this . defaultSerializer; defaultUsed = true ; } if ( this . valueSerializer == null ) { this . valueSerializer = this . defaultSerializer; defaultUsed = true ; } if ( this . hashKeySerializer == null ) { this . hashKeySerializer = this . defaultSerializer; defaultUsed = true ; } if ( this . hashValueSerializer == null ) { this . hashValueSerializer = this . defaultSerializer; defaultUsed = true ; } } if ( this . enableDefaultSerializer && defaultUsed) { Assert . notNull ( this . defaultSerializer, "default serializer null and not all serializers initialized" ) ; } if ( this . scriptExecutor == null ) { this . scriptExecutor = new DefaultScriptExecutor ( this ) ; } this . initialized = true ; }
}
public class RedisTemplate < K , V > extends RedisAccessor implements RedisOperations < K , V > , BeanClassLoaderAware { public void setKeySerializer ( RedisSerializer < ? > ) { this . keySerializer = serializer; }
}
if ( this . keySerializer == null ) { this . keySerializer = this . defaultSerializer; defaultUsed = true ; } if ( this . valueSerializer == null ) { this . valueSerializer = this . defaultSerializer; defaultUsed = true ; }
@AutoConfiguration
@ConditionalOnClass ( { RedisOperations . class } )
@EnableConfigurationProperties ( { RedisProperties . class } )
@Import ( { LettuceConnectionConfiguration . class , JedisConnectionConfiguration . class } )
public class RedisAutoConfiguration { @Bean @ConditionalOnMissingBean ( name = { "redisTemplate" } ) @ConditionalOnSingleCandidate ( RedisConnectionFactory . class ) public RedisTemplate < Object , Object > redisTemplate ( RedisConnectionFactory redisConnectionFactory) { RedisTemplate < Object , Object > = new RedisTemplate ( ) ; template. setConnectionFactory ( redisConnectionFactory) ; return template; }
}
package com. con fig; import com. fasterxml. jackson. annotation. JsonAutoDetect ;
import com. fasterxml. jackson. annotation. PropertyAccessor ;
import com. fasterxml. jackson. databind. ObjectMapper ;
import org. springframework. context. annotation. Bean ;
import org. springframework. context. annotation. Configuration ;
import org. springframework. data. redis. connection. RedisConnectionFactory ;
import org. springframework. data. redis. core. RedisTemplate ;
import org. springframework. data. redis. serializer. Jackson2JsonRedisSerializer ; @Configuration
public class RedisConfig { @Bean public RedisTemplate < Object , Object > redisTemplate ( RedisConnectionFactory redisConnectionFactory) { RedisTemplate < Object , Object > = new RedisTemplate ( ) ; template. setConnectionFactory ( redisConnectionFactory) ; Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer ( Object . class ) ; ObjectMapper om = new ObjectMapper ( ) ; om. setVisibility ( PropertyAccessor . ALL , JsonAutoDetect. Visibility . ANY ) ; om. enableDefaultTyping ( ObjectMapper. DefaultTyping . NON_FINAL ) ; jacksonSeial. setObjectMapper ( om) ; template. setDefaultSerializer ( jacksonSeial) ; return template; }
}
这样，对应的序列化就不是默认的了，而是我们设置的，我们访问http://localhost:8080/findCommentById?id=3和http://localhost:8080/api/findCommentById?id=3看看redis保存的结果吧（在一些情况下，如果编码一致还出现乱码，一般是给出的数据不能识别造成的），一般第二个方法比较好看了，与前面的GenericJackson2JsonRedisSerializer有点类似，也可以看看其value的值了
为什么操作缓存的使用自定义的序列化是不行的，这就需要前面我们说过的处理了，前面我们说过redis中的缓存管理器会额外的处理，一般可以认为他对key是一个他操作的序列化（可以认为是前面的StringRedisSerializer），但是默认value的序列化可能就是jdk序列化，所以上面的结果中get "comment::3"不变
@Configuration ( proxyBeanMethods = false
)
@ConditionalOnClass ( { RedisConnectionFactory . class } )
@AutoConfigureAfter ( { RedisAutoConfiguration . class } )
@ConditionalOnBean ( { RedisConnectionFactory . class } )
@ConditionalOnMissingBean ( { CacheManager . class } )
@Conditional ( { CacheCondition . class } )
class RedisCacheConfiguration { RedisCacheConfiguration ( ) { } @Bean RedisCacheManager cacheManager ( CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers, ObjectProvider < org. springframework. data. redis. cache. RedisCacheConfiguration> , ObjectProvider < RedisCacheManagerBuilderCustomizer > , RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) { RedisCacheManagerBuilder builder = RedisCacheManager . builder ( redisConnectionFactory) . cacheDefaults ( this . determineConfiguration ( cacheProperties, redisCacheConfiguration, resourceLoader. getClassLoader ( ) ) ) ; List < String > = cacheProperties. getCacheNames ( ) ; if ( ! cacheNames. isEmpty ( ) ) { builder. initialCacheNames ( new LinkedHashSet ( cacheNames) ) ; } if ( cacheProperties. getRedis ( ) . isEnableStatistics ( ) ) { builder. enableStatistics ( ) ; } redisCacheManagerBuilderCustomizers. orderedStream ( ) . forEach ( ( customizer) -> { customizer. customize ( builder) ; } ) ; return ( RedisCacheManager ) cacheManagerCustomizers. customize ( builder. build ( ) ) ; }
}
private org. springframework. data. redis. cache. RedisCacheConfigurationdetermineConfiguration ( CacheProperties cacheProperties, ObjectProvider < org. springframework. data. redis. cache. RedisCacheConfiguration> , ClassLoader classLoader) { return ( org. springframework. data. redis. cache. RedisCacheConfiguration) redisCacheConfiguration. getIfAvailable ( ( ) -> { return this . createConfiguration ( cacheProperties, classLoader) ; } ) ; } private org. springframework. data. redis. cache. RedisCacheConfigurationcreateConfiguration ( CacheProperties cacheProperties, ClassLoader classLoader) { Redis redisProperties = cacheProperties. getRedis ( ) ; org. springframework. data. redis. cache. RedisCacheConfiguration= org. springframework. data. redis. cache. RedisCacheConfiguration. defaultCacheConfig ( ) ; config = config. serializeValuesWith ( SerializationPair . fromSerializer ( new JdkSerializationRedisSerializer ( classLoader) ) ) ; if ( redisProperties. getTimeToLive ( ) != null ) { config = config. entryTtl ( redisProperties. getTimeToLive ( ) ) ; } if ( redisProperties. getKeyPrefix ( ) != null ) { config = config. prefixCacheNameWith ( redisProperties. getKeyPrefix ( ) ) ; } if ( ! redisProperties. isCacheNullValues ( ) ) { config = config. disableCachingNullValues ( ) ; } if ( ! redisProperties. isUseKeyPrefix ( ) ) { config = config. disableKeyPrefix ( ) ; } return config; } private final Map < String , RedisCacheConfiguration > ;
public class RedisCacheConfiguration { private final Duration ttl; private final boolean cacheNullValues; private final CacheKeyPrefix keyPrefix; private final boolean usePrefix; private final SerializationPair < String > ; private final SerializationPair < Object > ; private final ConversionService conversionService; }
一般对应的map可能只有一个，String可能会将key和缓存名称结合，所以前面出现comment::3，前面没有操作redis的基本是两个map
@Bean public RedisCacheManager cacheManager ( RedisConnectionFactory redisConnectionFactory) { RedisSerializer < String > = new StringRedisSerializer ( ) ; Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer ( Object . class ) ; ObjectMapper om = new ObjectMapper ( ) ; om. setVisibility ( PropertyAccessor . ALL , JsonAutoDetect. Visibility . ANY ) ; om. enableDefaultTyping ( ObjectMapper. DefaultTyping . NON_FINAL ) ; jacksonSeial. setObjectMapper ( om) ; RedisCacheConfiguration config = RedisCacheConfiguration . defaultCacheConfig ( ) . entryTtl ( Duration . ofDays ( 1 ) ) . serializeKeysWith ( RedisSerializationContext. SerializationPair . fromSerializer ( strSerializer) ) . serializeValuesWith ( RedisSerializationContext. SerializationPair . fromSerializer ( jacksonSeial) ) . disableCachingNullValues ( ) ; RedisCacheManager cacheManager = RedisCacheManager . builder ( redisConnectionFactory) . cacheDefaults ( config) . build ( ) ; return cacheManager; }
这样，我们重新启动，然后我们访问http://localhost:8080/findCommentById?id=3和http://localhost:8080/api/findCommentById?id=3看看redis保存的结果吧，看看结果：
ObjectMapper om = new ObjectMapper ( ) ; om. setVisibility ( PropertyAccessor . ALL , JsonAutoDetect. Visibility . ANY ) ; om. enableDefaultTyping ( ObjectMapper. DefaultTyping . NON_FINAL ) ; jacksonSeial. setObjectMapper ( om) ;
package com. json ; public class User { private String name; private int age; public User ( ) { } public User ( String name, int age) { this . name = name; this . age = age; } public String getName ( ) { return name; } public void setName ( String name) { this . name = name; } public int getAge ( ) { return age; } public void setAge ( int age) { this . age = age; } @Override public String toString ( ) { return "User{" + "name='" + name + '\'' + ", age=" + age + '}' ; }
}
package com. json ; import com. fasterxml. jackson. annotation. JsonAutoDetect ;
import com. fasterxml. jackson. annotation. PropertyAccessor ;
import com. fasterxml. jackson. databind. ObjectMapper ;
import com. fasterxml. jackson. databind. jsontype. impl. LaissezFaireSubTypeValidator ;
import org. springframework. data. redis. serializer. Jackson2JsonRedisSerializer ; import java. io. IOException ; public class ObjectMapperTest { public static void main ( String [ ] args) throws IOException { User user = new User ( "Alice" , 30 ) ; Jackson2JsonRedisSerializer < User > = new Jackson2JsonRedisSerializer < > ( User . class ) ; ObjectMapper defaultMapper = new ObjectMapper ( ) ; serializer. setObjectMapper ( defaultMapper) ; byte [ ] serializedDefault = serializer. serialize ( user) ; User deserializedDefault = serializer. deserialize ( serializedDefault) ; System . out. println ( "Default ObjectMapper:" ) ; System . out. println ( new String ( serializedDefault) ) ; System . out. println ( deserializedDefault) ; Jackson2JsonRedisSerializer < User > = new Jackson2JsonRedisSerializer < > ( User . class ) ; ObjectMapper om = new ObjectMapper ( ) ; om. setVisibility ( PropertyAccessor . ALL , JsonAutoDetect. Visibility . ANY ) ; om. activateDefaultTyping ( LaissezFaireSubTypeValidator . instance, ObjectMapper. DefaultTyping . NON_FINAL ) ; configuredSerializer. setObjectMapper ( om) ; byte [ ] serializedConfigured = configuredSerializer. serialize ( user) ; User deserializedConfigured = configuredSerializer. deserialize ( serializedConfigured) ; System . out. println ( "Configured ObjectMapper:" ) ; System . out. println ( new String ( serializedConfigured) ) ; System . out. println ( deserializedConfigured) ; }
}
public T deserialize ( @Nullable byte [ ] bytes) throws SerializationException { if ( SerializationUtils . isEmpty ( bytes) ) { return null ; } else { try { return this . objectMapper. readValue ( bytes, 0 , bytes. length, this . javaType) ; } catch ( Exception var3) { throw new SerializationException ( "Could not read JSON: " + var3. getMessage ( ) , var3) ; } } } public byte [ ] serialize ( @Nullable Object t) throws SerializationException { if ( t == null ) { return SerializationUtils . EMPTY_ARRAY ; } else { try { return this . objectMapper. writeValueAsBytes ( t) ; } catch ( Exception var3) { throw new SerializationException ( "Could not write JSON: " + var3. getMessage ( ) , var3) ; } } }
om. setVisibility ( PropertyAccessor . ALL , JsonAutoDetect. Visibility . ANY ) ; om. activateDefaultTyping ( LaissezFaireSubTypeValidator . instance, ObjectMapper. DefaultTyping . NON_FINAL ) ;
om. activateDefaultTyping ( LaissezFaireSubTypeValidator . instance, ObjectMapper. DefaultTyping . NON_FINAL ) ;
om. setVisibility ( PropertyAccessor . ALL , JsonAutoDetect. Visibility . ANY ) ;
![[Doris]阿里云搭建Doris，测试环境1FE 1BE](https://i-blog.csdnimg.cn/direct/3cc3269159214373b53f8420e2df769b.jpeg)
