Home - JAVA 牛牛

在数据库并发操作时，为了保证数据的正确性，经常要对数据加锁，加锁有两种方式：悲观锁、乐观锁

悲观锁：把所需要的数据全部加锁，不允许其他事务对数据做修改

update xxx where xxxx for update

乐观锁：对数据进行版本校验，如果版本不一致，则操作数据失败

update xxx,version+1  where xxxx and version=x
 ```

- @Version注解可以在实体 bean 中使用,通过这种方式可添加对乐观锁定的支持  
- 一个类中只能有一个@Version注解  
- 注意此属性 不能用 String  可取值 int Integer Long
- 在jpa中，@Version注解，可以实现乐观锁功能

实体类Account，version属性上加@Version注解
```java
package com.xhx.springboot.entity;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Version;

/**
 * @author xuhaixing
 * @date 2018/4/28 10:29
 */
@Entity
public class Account {
    @Id
    private int id;
    private String name;
    private Double money;
    @Version
    private int version;


    public int getVersion() {
        return version;
    }

    public void setVersion(int version) {
        this.version = version;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }
}

在更新数据时，需要用jpa自己实现的save方法

<S extends T> S save(S var1);
<S extends T> Iterable<S> saveAll(Iterable<S> var1);

如果是自己写的update方法，下面这样，是不生效的

@Repository
public interface AccountDao extends JpaRepository<Account, Integer> {
    @Modifying
    @Query("update Account set name=:name, money=:money where id=:id")
    int updateAccount(@Param("id") int id,@Param("name") String name, @Param("money") double money);

}

数据库数据如下：

我们更新id是10的数据，数据库中版本是0，我们设置版本1

Account account = new Account();
account.setId(10);
account.setName("eeee");
account.setMoney(7999.0);
account.setVersion(1);
accountController.update(account);

报如下错误：

org.springframework.orm.ObjectOptimisticLockingFailureException: Object of class [com.xhx.springboot.entity.Account] with identifier [10]: optimistic locking failed; nested exception is org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect) : [com.xhx.springboot.entity.Account#10]

	at org.springframework.orm.jpa.vendor.HibernateJpaDialect.convertHibernateAccessException(HibernateJpaDialect.java:298)
	at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:225)
	at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527)

把版本号改成0，再更新，数据库中执行如下语句，更新成功

再看数据库，版本号+1了

@Component : 组件,没有明确的角色
@Service : 在业务逻辑层(service层)使用
@Repository : 在数据访问层(dao层)使用.
@Controller : 在展现层(MVC–SpringMVC)使用

注入Bean的注解:

@Aautowired : Spring提供的注解. 实例化接口
@Inject : JSR-330提供的注解
@Resource : JSR-250提供的注解

配置文件的注解:

@Configuration : 声明当前类是个配置类,相当于一个Spring配置的xml文件.
@ComponentScan (cn.test.demo): 自动扫描包名下所有使用 - @Component - @Service - @Repository - @Controller 的类,并注册为Bean
@WiselyConfiguration : 组合注解可以替代 - @Configuration和- @ComponentScan
@Bean : 注解在方法上,声明当前方法的返回值为一个Bean.
@Bean(initMethod=”aa”,destroyMethod=”bb”)–> 指定 aa和bb方法在构造之后.Bean销毁之前执行. - @Component 和 - @Bean 的区别

AOP切面编程注解:

@Aspect : 声明这是一个切面
@After - @Before. - @Around 定义切面,可以直接将拦截规则(切入点 PointCut)作为参数
@PointCut : 专门定义拦截规则然后在 - @After - @Before. - @Around 中调用
@Transcational : 事务处理
@Cacheable : 数据缓存
@EnableAaspectJAutoProxy : 开启Spring 对这个切面(Aspect )的支持
@Target (ElementType.TYPE):元注解,用来指定注解修饰类的那个成员 –>指定拦截规则
@Retention(RetentionPolicy.RUNTIME) —>当定义的注解的- @Retention为RUNTIME时，才能够通过运行时的反射机制来处理注解.–>指定拦截规则
@JsonBackReference //序列化时，- @JsonBackReference标注的属性在会被忽略
@Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性. 如果一个属性并非数据库表的字段映射,就务必将其标示为- @Transient,否则,ORM框架默认其注解为- @Basic

Spring 常用配置:

@import :导入配置类
@Scope : 新建Bean的实例 - @Scope(“prototype”) 声明Scope 为 Prototype
@Value : 属性注入
@Value (“我爱你”) –> 普通字符串注入
@Value (“#{systemProperties[‘os.name’]}”) –>注入操作系统属性
@Value (“#{ T (java.lang.Math).random() * 100.0 }”) –> 注入表达式结果
@Value (“#{demoService.another}”) –> 注入其他Bean属性
@Value ( “classpath:com/wisely/highlight_spring4/ch2/el/test.txt” ) –> 注入文件资源
@Value (“http://www.baidu.com”)–>注入网址资源
@Value (“${book.name}” ) –> 注入配置文件注意: 使用的是$ 而不是 #
@PostConstruct : 在构造函数执行完之后执行
@PreDestroy : 在 Bean 销毁之前执行
@ActiveProfiles : 用来声明活动的 profile
@profile: 为不同环境下使用不同的配置提供了支持 - @Profile(“dev”) …….对方法名为 dev-xxxx的方法提供实例化Bean
@EnableAsync : 开启异步任务的支持(多线程)
@Asyns : 声明这是一个异步任务,可以在类级别和方法级别声明.
@EnableScheduling : 开启对计划任务的支持(定时器)
@Scheduled : 声明这是一个计划任务支持多种计划任务,包含 cron. fixDelay fixRate
@Scheduled (dixedDelay = 5000) 通过注解定时更新
@Conditional : 条件注解,根据满足某一特定条件创建一个特定的Bean
@ContextConfiguration : 加载配置文件
@ContextConfiguration(classes = {TestConfig.class})
@ContextConfiguration用来加载ApplicationContext classes属性用来加载配置类
@WebAppCofiguration : 指定加载 ApplicationContext是一个WebApplicationContext
@Enable*注解:
@EnableAsync : 开启异步任务的支持(多线程)
@EnableScheduling : 开启对计划任务的支持(定时器)
@EnableWebMVC : 开启对Web MVC 的配置支持
@EnableAaspectJAutoProxy : 开启Spring 对这个切面(Aspect )的支持
@EnableConfigurationProperties 开启对- @ConfigurationProperties注解配置Bean的支持
@EnableJpaRepositories : 开启对Spring Data JAP Repository 的支持
@EnableTransactionManagement 开启对注解式事物的支持
@EnableCaching开启注解是缓存的支持.
@EnableDiscoveryClient 让服务发现服务器,使用服务器.Spring cloud 实现服务发现
@EnableEurekaServer 注册服务器 spring cloud 实现服务注册- @
@EnableScheduling 让spring可以进行任务调度,功能类似于spring.xml文件中的命名空间<task:* >
@EnableCaching 开启Cache缓存支持; SpringMVC 常用注解:
@Controller : 注解在类上声明这个类是springmvc里的Controller,将其声明为一个spring的Bean.
@RequestMapping :可以注解在类上和方法上映射WEB请求(访问路径和参数)
@RequestMapping(value= “/convert”,produces+{“application/x-wisely”}) 设置访问URL 返回值类型
@ResponseBody : 支持将返回值放入response体内而不是返回一个页面(返回的是一个组数据)
@RequestBody : 允许request的参数在request体中,而不是直接连接在地址后面次注解放置在参数前 ```
@PathVariable(“xxx”) 通过 - @PathVariable 可以将URL中占位符参数{xxx}绑定到处理器类的方法形参中- @PathVariable(“xxx“)
@RequestMapping(value=”user/{id}/{name}”) 请求路径：http://localhost:8080/hello/show5/1/james ```
@Qualifier：限定描述符，用于细粒度选择候选者；
@Path Variable : 用来接收路径参数如/test/001,001为参数,次注解放置在参数前
@RestController : - @Controller + - @ResponseBody 组合注解
@ControllerAdvice : 通过- @ControllerAdvice可以将对已控制器的全局配置放置在同一个位置
@ExceptionHandler : 用于全局处理控制器的异常
@ExceptionHandier(value=Exception.class) –>通过value属性可过滤拦截器条件,拦截所有的异常
@InitBinder : 用来设置WebDataBinder , WebDataBinder用来自动绑定前台请求参数到Model中.
@ModelAttrbuute : 绑定键值对到Model中,
@RunWith : 运行器
@RunWith(JUnit4.class)就是指用JUnit4来运行
@RunWith(SpringJUnit4ClassRunner.class),让测试运行于Spring测试环境
@RunWith(Suite.class)的话就是一套测试集合，
@WebAppConfiguration(“src/main/resources”) : 注解在类上,用来声明加载的ApplicationContex 是一个WebApplicationContext ,它的属性指定的是Web资源的位置,默认为 src/main/webapp ,自定义修改为 resource
@Before : 在 xxx 前初始化

Spring Boot 注解:

- @SpringBootApplication : 是Spring Boot 项目的核心注解主要目的是开启自动配置

@SpringBootApplication注解是一个组合注解,主要组合了- @Configuration .+- @EnableAutoConfiguration.+- @ComponentScan
@Value : 属性注入,读取properties或者 Yml 文件中的属性
@ConfigurationProperties : 将properties属性和一个Bean及其属性关联,从而实现类型安全的配置
@ConfigurationProperties(prefix = “author”,locations = {“classpath:config/author.properties”}) 通过- @ConfigurationProperties加载配置,通过prefix属性指定配置前缀,通过location指定配置文件位置
@EnableAutoConfiguration 注解:作用在于让 Spring Boot 根据应用所声明的依赖来对 Spring 框架进行自动配置这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。
@ Configuration 注解，以明确指出该类是 Bean 配置的信息源
@ComponentScan 注解会告知Spring扫描指定的包来初始化Spring Bean这能够确保我们声明的Bean能够被发现。
@ImportResource 注解加载XML配置文件
@EnableAutoConfiguration(exclude={xxxx.class}) 禁用特定的自动配置
@SpringBootApplication 注解等价于以默认属性使用- @Configuration，- @EnableAutoConfiguration和 - @ComponentScan。

- @SuppressWarnings注解

@SuppressWarnings(“unchecked”) 告诉编译器忽略 unchecked 警告信息,如使用 list ArrayList等未进行参数化产生的警告信息
@SuppressWarnings(“serial”) 如果编译器出现这样的警告信息: The serializable class WmailCalendar does not declare a static final serialVersionUID field of type long 使用这个注释将警告信息去掉。
@SuppressWarnings(“deprecation”) 如果使用了使用- @Deprecated注释的方法，编译器将出现警告信息。使用这个注释将警告信息去掉。
@SuppressWarnings(“unchecked”, “deprecation”) 告诉编译器同时忽略unchecked和deprecation的警告信息。
@SuppressWarnings(value={“unchecked”, “deprecation”}) 等同于- @SuppressWarnings(“unchecked”, “deprecation”) 案例
@Entity
@Table(name =”S_PRODUCEINFO”)
@Data
@Builder : 注解在类上, 为类提供一个内部的 Builder
@NoArgsConstructor //无参构造函数
@AllArgsConstructor //会生成一个包含所有变量，同时如果变量使用了NotNull annotation ，会进行是否为空的校验，全部参数的构造函数的自动生成，该注解的作用域也是只有在实体类上，参数的顺序与属性定义的顺序一致。 ```java publicclassProduceInfoEntity {

- @Id - @Column(name = “app_name”, unique =true, length = 50) privateStringname;

- @Column(name = “status”) - @Enumerated(EnumType.STRING) privateProduceStatusstatus;

- @Column(name = “create_time”, updatable =false) - @Temporal(TemporalType.TIMESTAMP) - @CreationTimestamp privateDatecreateTime;

- @Column(name = “update_time”) - @Temporal(TemporalType.TIMESTAMP) - @UpdateTimestamp privateDateupdateTime;

@Entity : 映射数据库实体类
@Table(name =”S_PRODUCEINFO”) : 表名为 ”S_PRODUCEINFO”
@Data：这个注解是lombok包下的一个注解，只要你的类上写了这个注解，那就不需要再生成get、set、toString等方法了。使用前要安装插件
@Id : 声明主键ID
@Column(name =”app_name”, unique =true, length = 50) :对应数据库字段,属性
@Enumerated(EnumType.STRING) : 采用枚举值类型和数据库字段进行交互
@Temporal : 时间格式映射数据库会得到规定时间格式的日期 - @Enumerted(EnumType.STRING) HH:MM:SS 格式的日期 - @Enumerted(EnumType.DATE) 获取年月日 yyyy-MM-dd - @Enumerted(EnumType.TIME) 获取时分秒 HH:MM:SS

```java
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
    /**
     * 不JSON 序列化此属性
     */
    - @JsonIgnore
    private String orgName;

    /**
     * 用户ID字符串 解析后格式为：{"userIdStr":"324324325345555554433244"}
     */
    - @JsonProperty("userIdStr")
    public String getUserIdStr() {
        return String.valueOf(getUserId());
    }

    /**
     * 格式化日期属性
     */
    - @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

异常：No runnable methods
原因：@Test时import的是@org.testng.annotations.Test所以会报错
解决方法:改为import org.junit.Test

异常：JPA连接MySQL报错Table 'test.hibernate_sequence' doesn't exist
原因：设计数据库时（DDL），没有设置 id 自增
解决方法：@GeneratedValue(strategy = GenerationType.AUTO) 改成GenerationType.IDENTITY

异常：password (should be mapped with insert="false" update="false")
原因：某参数被重复定义，如@Column(name = "password"） 被定义了两次以上
解决方法：@Column定义数据库字段的过程中，name的值保证唯一性

异常：Could not write JSON: Infinite recursion (StackOverflowError)
对应项目：[Github](https://github.com/mcks2000/springboot-buckets/springboot-restful)
原因：返回的json数据死循环
解决方法：在父类get方法添加 @JsonManagedReference 子类get方法添加 @JsonBackReference

异常：Cannot deserialize instance of
对应项目：[Github](https://github.com/mcks2000/springboot-buckets/springboot-restful)
原因：参数为List 少用了 []
解决方法： 在入参值上面添加 []

异常：java.lang.ClassNotFoundException: com.mysql.cj.jdbc.Driver
对应项目：[Github](https://github.com/mcks2000/springboot-buckets/springboot-hibernate)
原因：mysql版本不支持
解决方法：版本 5.7 -> 8.0.19

异常：org.hibernate.QueryException: Legacy-style query parameters (`?`) are no longer supported
对应项目：[Github](https://github.com/mcks2000/springboot-buckets/springboot-hibernate)
原因：hibernate最新版本需要在参数上添加序号
解决方法：比如
this.getHibernateTemplate().find("from Product p where p.pname=?", name);
改为
this.getHibernateTemplate().find("from Product p where p.pname=?0", name);
多个参数依次递增

异常：Could not get constructor for org.hibernate.persister.entity.SingleTableEntityPersister报错解决办法
原因：没有javassist 包
解决方法： 添加javassist包

异常：javax.net.ssl.SSLException: closing inbound before receiving peer's close_notify的解决办法
解决方法：配置连接数据库的url时，加上useSSL=false

Github源码地址

一句话简介

Java Persistence API定义了一种定义，可以将常规的普通Java对象（有时被称作POJO）映射到数据库

映射规则：

实体类__必须__用 @javax.persistence.Entity 进行注解；
必须__使用 @javax.persistence.__Id 来注解一个主键；
实体类必须拥有一个 public 或者 protected 的无参构造函数，之外实体类还可以拥有其他的构造函数；
实体类必须是一个 顶级类（top-level class）。一个枚举（enum）或者一个接口（interface）不能被注解为一个实体；
实体类不能是 final 类型的，也 不能有 final 类型的方法；
如果实体类的一个实例需要用传值的方式调用（例如，远程调用），则这个实体类必须实现（implements）java.io.Serializable 接口。
不与@Table结合的话表名默认为 SnakeCaseStrategy(命名策略 )为表名
若使用 name属性且没有与@Table结合则表名为 name值的SnakeCaseStrategy(命名策略 )
```
@Entity  
public class UserEntity{...} 表名 user_entity  
@Entity(name="UE")  
public class UserEntity{...} 表名 ue  
@Entity(name="UsEntity")  
public class UserEntity{...} 表名 us_entity
```
映射规则可以通过使用 @Table 和 @Column 注解修改

@Table
- @Table注解的常用选项是 name，用于指明数据库的表名
- @Table注解还有两个选项 catalog 和 schema 用于设置表所属的数据库目录或模式，通常为数据库名

@Column

@Column注解用来改变class中字段名与db中表的字段名的映射规则

@Column注释定义了将成员属性映射到关系表中的哪一列和该列的结构信息，属性如下：
　　1）name：映射的列名。如：映射tbl_user表的name列，可以在name属性的上面或getName方法上面加入；
　　2）unique：是否唯一；
　　3）nullable：是否允许为空；
　　4）length：对于字符型列，length属性指定列的最大字符长度；
　　5）insertable：是否允许插入；
　　6）updatetable：是否允许更新；
　　7）columnDefinition：定义建表时创建此列的DDL；
　　8）secondaryTable：从表名。如果此列不建在主表上（默认是主表），该属性定义该列所在从表的名字

hibernate中@Entity和@Table的区别：

@Entity说明这个class是实体类，并且使用默认的orm规则，即class名即数据库表中表名，class字段名即表中的字段名如果想改变这种默认的orm规则，就要使用@Table来改变class名与数据库中表名的映射规则，@Column来改变class中字段名与db中表的字段名的映射规则

@MappedSuperclass和@Entity的区别

使用场景

数据库表中都需要id来表示编号，id是这些映射实体类的通用的属性，交给jpa统一生成主键id编号，那么使用一个父类来封装这些通用属性，并用@MappedSuperclas标识。

示例

public abstract class IdEntity {
    protected Integer id;
    public abstract Integer getId();
    public abstract void setId(Integer id);

}

@MappedSuperclass
public abstract class BaseEntity extends IdEntity {

    @Id
    @GeneratedValue
    @Column(length=20)   
    public Integer getId() {
        return this.id;
    }
    public void setId(Integer id) {
        this.id = id;
    }

}

@Entity
@Table(name="yyw_user")
@Cache(usage= org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE)
public class User extends BaseEntity {
    @Column(length=20,nullable=false)
    private String name;
    @Column(length=20,nullable=true)
    private String password;

    public User(){}
    public User(String name, String password) {
        super();
        this.name = name;
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", id=" + id + ", password=" + password
                + "]";
    }
}

@Entity
@Table(name="yyw_subjects")
@Cache(usage= org.hibernate.annotations.CacheConcurrencyStrategy.READ_WRITE)
public class Subject extends BaseEntity {

    @Column(length=20,nullable=false)
    private String content;
    public Subject(){}
    public Subject(String content){
        this.content = content;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    public String toString() {
        return "Subject [id=" + id + ", content=" + content + "]";
    }
}

注意:

标注为@MappedSuperclass的类将不是一个完整的实体类，他将 不会映射到数据库表，但是 他的属性都将映射到其子类的数据库字段中。
标注为@MappedSuperclass的类 不能再标注@Entity或@Table注解，也 无需实现序列化接口。

@SecondaryTable 的使用

将一个实体类映射到数据库 两张或更多表 中呢表中

示例

@Entity
 @SecondaryTables({
    @SecondaryTable(name = "Address"),
    @SecondaryTable(name = "Comments")
 })
 public class Forum implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue
    private Long id;
    private String username;
    private String password;
    @Column(table = "Address", length = 100)
    private String street;
    @Column(table = "Address", nullable = false)
    private String city;
    @Column(table = "Address")
    private String conutry;
    @Column(table = "Comments")
    private String title;
    @Column(table = "Comments")
    private String Comments;
    @Column(table = "Comments")
    private Integer comments_length;

    // Getters and Setters
 }

ER图

图片pic1

其他注解

@ManyToOne （多对一）单向：不产生中间表，但可以用@Joincolumn（name=” “）来指定生成外键的名字，外键在多的一方表中产生

@OneToMany （一对多）单向：会产生中间表，此时可以用@onetoMany @Joincolumn（name=” “）避免产生中间表，并且指定了外键的名字（别看@joincolumn在一中写着，但它存在在多的那个表中,通常配合List 一起使用）

@OneToMany ,@ManyToOne 双向（两个注解一起用的）：如果不在@OneToMany中加mappedy属性就会产生中间表，此时通常在@ManyToOne的注解下再添上注解@Joincolumn(name=” “)来指定外键的名字(说明：多的一方为关系维护端，关系维护端负责外键记录的更新，关系被维护端没有权利更新外键记录)！（@OneToMany(mappedBy=”一对多中，多中一的属性”)出现mapby为被维护端|||默认为延迟加载)

//用例：
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name="child_id")
private OrderChild orderChild;

@OneToMany(mappedBy="orderChild",fetch=FetchType.LAZY,cascade={CascadeType.MERGE})
@NotFound(action=NotFoundAction.IGNORE)//代表可以为空，允许为null
private List<OrderChildGoods> goodsList;
//hibernate中@ManyToOne默认是立即加载，@OneToMany默认是懒加载

//但是如果加上了@NotFound之后设置的fetch=FetchType.LAZY是不起作用的，也就是设置@NotFound后变为了立即加载eager

@JoinColumn

@ManyToOne //多个公告对于一个管理员
@JoinColumn(columnDefinition="BIGINT(20) NOT NULL COMMENT '创建管理员ID'")
//JoinColumn 不添加name属性，按照生成数据库字段的规则_id 数据库中字段 create_admin_id
private Admin createAdmin;

@Lob 大对象存储类型

@Lob
@Column(columnDefinition = "TEXT COMMENT '商品描述'")
private String note;
//`note` text CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL COMMENT '商品描述',

@Transient 将不需要序列化的属性前添加关键字transient @Transient详情

@Embeddable 嵌套映射

@CreationTimestamp 根据当前时间来生成默认的时间戳（insert时生成）

@UpdateTimestamp 根据当前时间来生成默认的时间戳（update是更新）

@Inheritance Hibernate继承策略,总共有三种SINGLE_TABLE、TABLE_PER_CLASS 和 JOINED

@id

如果是主键id，还会用到@Id注解

@Id注释指定表的主键，它可以有多种生成方式：
　　1）TABLE：容器指定用底层的数据表确保唯一；
　　2）SEQUENCE：使用数据库德SEQUENCE列莱保证唯一（Oracle数据库通过序列来生成唯一ID）；
　　3）IDENTITY：使用数据库的IDENTITY列莱保证唯一；
　　4）AUTO：由容器挑选一个合适的方式来保证唯一；
　　5）NONE：容器不负责主键的生成，由程序来完成。

双向关联模型

@Entity
@Table(name="address")
public class AddressEO implements java.io.Serializable {

  @ManyToOne(cascade = { CascadeType.ALL })
  @JoinColumn(name="customer_id")//外键字段
  private CustomerEO customer;

  // ...
}

@Entity
@Table(name="customer")
public class CustomerEO {

  @OneToMany(mappedBy="customer")
  private Collection<AddressEO> addresses = new ArrayList<AddressEO>();

  // ...
}
//其中，@OneToMany标记中的mappedBy属性的值为AddressEO实体中所引用的CustomerEO实体的属性名

总结

@Entity @Table 区别通过上面博文可得出
@Entity @Table 通常同时出现
@MappedSuperclass类相当于把通用属性放在一起，再让之类继承实现

参考链接

原理

DynamicUpdate: 在只更新同一个session里面，同一个对象有改变的字段。说白了, 就是在更新某条记录之前, 先把这条记录从数据库查出来, 那么这条数据就在session(一级缓存)中, 我们再去修改这个对象的数据即可;

@DynamicUpdate正确使用方式

在做 update实体类的某个属性之前，先做findById操作
将需要修改的字段做 set 操作
做 save 操作

误区及经常出现的错误

更新数据时，只传入需要更新的数据，而没有操作findById操作,造成其他数据为null

举例

先说明一下@DynamicUpdate注解用在实体类上
有数据库表tbl_foo和对应的实体类Foo，如下：

id	name	col3	col4	col5
1	毕加索	1770	奥地利	男

class Foo{
    private Integer id;
    private String name;
    private String col3;
    private String col4;
    private String col5;
    getter...
    setter...
}

在Service中更新id=1记录的name属性，代码如下：

Foo foo = fooDao.findById(1);
foo.setName("贝多芬");
fooDao.save(foo);

两种情况：

在entity类中未使用@DynamicUpdate注解或使用了@DynamicUpdate(false)，那么Hibernate底层执行的sql如:
```
update tbl_foo set name=?, col3=?, col4=?, col5=? where id=?
```
在entity类中使用了@DynamicUpdate注解(或@DynamicUpdate(true))，Hibernate底层执行的sql如:
```
update tbl_foo set name=? where id=?
```

以上两种情况对数据库更新的结果是等效的，但是使用@DynamicUpdate性能会好一些。因为不使用@DynamicUpdate时，即使没有改变的字段也会被更新。如果进行频繁的更新操作，并且每次只更新少数字段，那么@DynamicUpdate对性能的优化效果还是很好的。

1. 概述

在此教程中，我们将演示如何使用 Spring Cache 创建自定义密钥生成器。

2. KeyGenerator

这负责为缓存中的每个数据项生成每个键，这些键将用于在检索时查找数据项。

此处的默认实现是SimpleKeyGenerator –它使用提供的方法参数来生成密钥。这意味着，如果我们有两个使用相同的缓存名称和参数类型集的方法，则很有可能会导致冲突。

它还意味着缓存数据可以由另一种方法覆盖。

3. 自定义密钥生成器

密钥生成器只需要实现一个方法：

Object generate(Object object, Method method, Object... params)

如果未正确实现或使用，则可能导致覆盖缓存数据。

让我们来看看实现：

public class CustomKeyGenerator implements KeyGenerator {

    public Object generate(Object target, Method method, Object... params) {
        return target.getClass().getSimpleName() + "_"
          + method.getName() + "_"
          + StringUtils.arrayToDelimitedString(params, "_");
    }
}

之后，我们有两种可能的方式使用它;第一种是在应用程序Config中声明一个豆。

请务必指出，类必须从缓存配置支持或实现缓存配置程序扩展：

@EnableCaching
@Configuration
public class ApplicationConfig extends CachingConfigurerSupport {

    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        Cache booksCache = new ConcurrentMapCache("books");
        cacheManager.setCaches(Arrays.asList(booksCache));
        return cacheManager;
    }

    @Bean("customKeyGenerator")
    public KeyGenerator keyGenerator() {
        return new CustomKeyGenerator();
    }
}

第二种方法是将其用于特定方法：

@Component
public class BookService {

    @Cacheable(value = "books", keyGenerator = "customKeyGenerator")
    public List<Book> getBooks() {
        List<Book> books = new ArrayList<>();
        books.add(new Book("The Counterfeiters", "André Gide"));
        books.add(new Book("Peer Gynt and Hedda Gabler", "Henrik Ibsen"));
        return books;
    }
}

4. 结论

在本文中，我们探讨了实现自定义春季缓存的密钥生成器的方法。

与往常一样，示例的完整源代码可在 GitHub 上找到。

一句话介绍

Hamcrest是用于Java的单元测试的框架，它使用matcher匹配器来进行断言。在Spring-boot-starter中集成了Hamcrest,无需而外引入。

核心API

使用is匹配器使得程序更加易懂

String str1 = "text";
String str2 = " text ";
assertThat(str1, is(equalToIgnoringWhiteSpace(str2)));

用于简单数据类型的判断

String str1 = "text";
String str2 = "text";
assertThat(str1, is(str2));

not
和is使用方式一样，只是含义相反。

使用not匹配器使得程序更加易懂

String str1 = "text";
String str2 = " text ";
assertThat(str1, not(equalToIgnoringWhiteSpace(str2)));

用于简单数据类型的判断

String str1 = "text";
String str2 = "text";
assertThat(str1, not(str2));

containsString

是否包含子串

String str1 = "text123";
String str2 = "text";
assertThat(str1, containsString(str2));

以为某个字段开头/结尾

String str1 = "text123";
assertThat(str1, startsWith("text"));// 以某个字符开头
assertThat(str1, endsWith("text"));// 以某个字符开头

判断两个对象是否为同一个实体

Cat cat=new Cat();
assertThat(cat, sameInstance(cat));

类似OR的效果

String str = "calligraphy";
String start = "call";
String end = "foo";
assertThat(str, anyOf(startsWith(start), containsString(end)));

类似AND的效果

String str = "calligraphy";
String start = "call";
String end = "phy";
assertThat(str, allOf(startsWith(start), endsWith(end)));

匹配器

Number 匹配器

assertThat(1, greaterThan(0)); // 大于
assertThat(5, greaterThanOrEqualTo(5)); //大于等于
assertThat(-1, lessThan(0)); // 小于
assertThat(-1, lessThanOrEqualTo(5)); // 小于等于

Text 匹配器

匹配空串

String str = "";
assertThat(str, isEmptyString()); // 空字符串
assertThat(str, isEmptyOrNullString()); // 空字符串或者null

匹配字符串相等

String str1 = "text";
String str2 = " text ";
assertThat(str1, equalToIgnoringWhiteSpace(str2)); // 忽略左右空白
assertThat(a, equalToIgnoringCase(b)); //忽略大小写

Collections 匹配器

检查某个元素是否在集合中

List<String> collection = Lists.newArrayList("ab","cd","ef");
assertThat(collection, hasItem("cd"));
assertThat(collection, not(hasItem("zz")));
assertThat(collection, hasItems("cd", "ab")); // 检查多个元素是否在集合中

检查所有元素

List<String> collection = Lists.newArrayList("ab","cd","ef");
assertThat(collection, hasItems("ab","cd","ef"));
assertThat(collection, hasItems("cd", "ab","ef")); // 错误
assertThat(collection, hasItems("ab","cd")); // 错误
assertThat(collection, containsInAnyOrder("cd", "ab","ef")); //正确,不区分顺序

为空检查

集合为空检查

List<String> collection = Lists.newArrayList("ab","cd","ef");
assertThat(collection, empty()); // false, 用于检查集合类型

数组为空检查

String[] array = new String[] { "ab" };
assertThat(array, emptyArray()); // false

map为空检查

Map<String, String> maps = Maps.newHashMap();
assertThat(maps, equalTo(Collections.EMPTY_MAP));

Iterable为空检查

Iterable<String> collection = Lists.newArrayList();
assertThat(collection, emptyIterable());

检查数目

检查集合数目

List<String> list = Lists.newArrayList("ab", "cd", "ef");
assertThat(list, hasSize(3));

检查iterable数目

Iterable<String> list = Lists.newArrayList("ab", "cd", "ef");
assertThat(list, iterableWithSize(3));

检查每项的条件

List<String> list = Lists.newArrayList("ab", "cd", "ef");
assertThat(list, everyItem(equalTo("ab")));

Bean 匹配器

定义一个City的bean

@Data
@AllArgsConstructor
public class City {
    String name;
    String state;
}

测试是否存在某个属性

City city = new City("shenzhen", "CA");
assertThat(city, hasProperty("state"));
assertThat(city, hasProperty("state", equalTo("CA"))); // 判断是否存在某个属性，并且是否存在某个特性值

判断两个对象property值是否一样

City city = new City("San Francisco", "CA");
City city2 = new City("San Francisco", "CA");
assertThat(city, samePropertyValuesAs(city2));

源码地址 springboot-async

异步线程池-三种方式

@Ansync
DeferredResult
WebAsyncTask

演示在SpringBoot中如何使用异步线程池

主要类

AsyncUncaughtExceptionHandler 处理异常通过继承 AsyncConfigurer 可得
ThreadPoolTaskExecutor 线程池配置，异步处理伴随着多请求，少不了线程处理

主要注解

@Ansync 方法注解
@EnableAsync 类注解，可在配置类中添加

339 post articles, 43 pages.

声明Bean的注解: