这里续写上一章博客（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/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/cache
http://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=UTC
username : root
password : 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 ) ;
