SpringData概述

合集下载

mongotemplate.find分页查询语句

mongotemplate.find分页查询语句1. 引言1.1 概述MongoDB是一种广泛使用的NoSQL数据库，在实际开发中，数据查询和分页查询是非常常见的操作。

mongotemplate.find()方法是Spring Data MongoDB提供的一个用于执行查询操作的方法，它允许我们根据指定的条件从集合中获取文档。

本篇文章将重点介绍mongotemplate.find分页查询语句的使用方法。

通过本文，读者将了解到如何使用该方法进行分页查询，并掌握一些优化技巧和注意事项。

1.2 文章结构本文将按照以下结构展开对mongotemplate.find分页查询语句进行详细介绍：- 第2部分：mongotemplate.find分页查询语句的背景知识。

我们将首先介绍MongoDB和Spring Data MongoDB以及mongotemplate这些基础概念，为后续内容打下基础。

- 第3部分：分页查询的基本原理与实现方式。

我们会解释什么是分页查询、其作用以及不同实现方式之间的比较与选择，此外还会详细讲解mongotemplate.find分页查询方法的使用步骤。

- 第4部分：mongotemplate.find分页查询语句的具体使用方法。

我们将具体介绍该方法的参数设置与结果控制选项说明，并给出示例代码演示和解析，同时分享一些分页查询语句的优化技巧和注意事项。

- 第5部分：结论。

我们将总结本文的要点，并提出一些具有参考价值的结论，以帮助读者更好地理解和应用mongotemplate.find分页查询语句。

1.3 目的通过本文，希望读者能够全面了解mongotemplate.find分页查询语句的使用方法及其背后的原理。

无论是初学者还是有经验的开发人员，都可以从本文中获取相关知识并加以运用。

最终，读者将能够熟练使用mongotemplate.find方法来实现高效、精确的分页查询功能，并在实际项目中取得更好的效果。

通过JPA注解映射视图的实体类jpa视图无主键@Query注解的用法（SpringData。。。

通过JPA注解映射视图的实体类jpa视图⽆主键@Query注解的⽤法（SpringData。

这⾥主要说⼀下怎么⽤jpa映射⼀个视图的实体类，其实跟表映射⼀样，就是需要添加⼀个空的主键id标识package com.cf.bus.core.rs.template.domain;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name = "v_sc_template") // 这个是视图名称public class SupplyChainTemplate {@Id // 添加⼀个空的id标识，因为jpa在映射实体是需要⼀个id，这个必须@Column(name = "name")private String name;@Column(name = "industry")private String industry;@Column(name = "com_type")private String comType;@Column(name = "remarks")private String remarks;public String getName() {return name;}public void setName(String name) { = name;}public String getIndustry() {return industry;}public void setIndustry(String industry) {this.industry = industry;}public String getComType() {return comType;}public void setComType(String comType) {Type = comType;}public String getRemarks() {return remarks;}public void setRemarks(String remarks) {this.remarks = remarks;}}@id⼀定要有，否则会报构建entityManagerFactory异常。

SpringDtataJPA_计算机软件及应用_IT计算机_专业资料

Spring Data JPA最近项目中使用了Spring Data JPA这套基于持久化层的一套查询规范( 即基于ORM和JPA )。

今天自己整理一下这套“框架”的使用说明JPA:JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

使用Spring Data Jpa要引入相应的jar 文件。

使用此规范只要实现几个重要的接口即可，首先看下这几个接口的关系那了解了接口之后该如何使用呢：public interface JPATests extends JpaRepository<T, ID> {}//如上面代码：jpaTests 是我自己创建的一个接口，该接口继承了JpaRepository<T,ID> 该接口引用泛型，T指该接口实现的实体类，ID是主键的类型。

不用编写任何代码即可使用jpa带来的敏捷开发，对我们开发人员来说无疑是欣喜若狂。

那这个接口都实现了哪些方法呢？你可以去Spring Data Jpa的源码中看，该接口有个实现里面就是它方法的实现逻辑算法：下面我贴出代码：@Transactional(readOnly = true)public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>,JpaSpecificationExecutor<T> {private final JpaEntityInformation<T, ?> entityInformation;private final EntityManager em;private final PersistenceProvider provider;private LockMetadataProvider lockMetadataProvider;/*** Creates a new {@link SimpleJpaRepository}to manage objects of the given {@link JpaEntityInformation}.** @param entityInformation must not be {@literal null}.* @param entityManager must not be {@literal null}.*/public SimpleJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {Assert.notNull(entityInformation);Assert.notNull(entityManager);this.entityInformation = entityInformation;this.em = entityManager;this.provider =PersistenceProvider.fromEntityManager(entityManager);}/*** Creates a new {@link SimpleJpaRepository}to manage objects of the given domain type.** @param domainClass must not be {@literal null}.* @param em must not be {@literal null}.*/public SimpleJpaRepository(Class<T> domainClass, EntityManager em) {this(JpaEntityInformationSupport.getMetadata(domainClass, em), em);}/*** Configures a custom {@link LockMetadataProvider} to be used to detect {@link LockModeType}s to be applied to* queries.** @param lockMetadataProvider*/public void setLockMetadataProvider(LockMetadataProvider lockMetadataProvider) {this.lockMetadataProvider = lockMetadataProvider;}private Class<T> getDomainClass() {return entityInformation.getJavaType();}private String getDeleteAllQueryString() {return getQueryString(DELETE_ALL_QUERY_STRING, entityInformation.getEntityName());}private String getCountQueryString() {String countQuery = String.format(COUNT_QUERY_STRING, provider.getCountQueryPlaceholder(), "%s");return getQueryString(countQuery,entityInformation.getEntityName());}/** (non-Javadoc)* @seeorg.springframework.data.repository.CrudRepository#delete(java.io.Se rializable)*/@Transactionalpublic void delete(ID id) {Assert.notNull(id, "The given id must not be null!");if (!exists(id)) {throw newEmptyResultDataAccessException(String.format("No %s entity with id %s exists!",entityInformation.getJavaType(), id), 1);}delete(findOne(id));}/** (non-Javadoc)* @seeorg.springframework.data.repository.CrudRepository#delete(ng. Object)*/@Transactionalpublic void delete(T entity) {Assert.notNull(entity, "The entity must not be null!");em.remove(em.contains(entity) ? entity : em.merge(entity));}/** (non-Javadoc)* @seeorg.springframework.data.repository.CrudRepository#delete(ng. Iterable)*/@Transactionalpublic void delete(Iterable<? extends T> entities) {Assert.notNull(entities, "The given Iterable of entities not be null!");for (T entity : entities) {delete(entity);}}/** @seeorg.springframework.data.jpa.repository.JpaRepository#deleteInBatch( ng.Iterable)*/@Transactionalpublic void deleteInBatch(Iterable<T> entities) {Assert.notNull(entities, "The given Iterable of entities not be null!");if (!entities.iterator().hasNext()) {return;}applyAndBind(getQueryString(DELETE_ALL_QUERY_STRING, entityInformation.getEntityName()), entities, em).executeUpdate();}/** (non-Javadoc)* @see org.springframework.data.repository.Repository#deleteAll() */@Transactionalpublic void deleteAll() {for (T element : findAll()) {delete(element);}}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaRepository#deleteAllInBat ch()*/@Transactionalpublic void deleteAllInBatch() {em.createQuery(getDeleteAllQueryString()).executeUpdate();}/*** @see*org.springframework.data.repository.Repository#readById(java.io.Seri alizable* )*/public T findOne(ID id) {Assert.notNull(id, "The given id must not be null!");return em.find(getDomainClass(), id);}/** (non-Javadoc)* @seeorg.springframework.data.repository.CrudRepository#exists(java.io.Se rializable)*/public boolean exists(ID id) {Assert.notNull(id, "The given id must not be null!");if (entityInformation.getIdAttribute() != null) {String placeholder = provider.getCountQueryPlaceholder();String entityName = entityInformation.getEntityName();Iterable<String> idAttributeNames =entityInformation.getIdAttributeNames();String existsQuery =QueryUtils.getExistsQueryString(entityName, placeholder, idAttributeNames);TypedQuery<Long> query = em.createQuery(existsQuery, Long.class);if (entityInformation.hasCompositeId()) {for (String idAttributeName : idAttributeNames) {query.setParameter(idAttributeName, entityInformation.getCompositeIdAttributeValue(id, idAttributeName));}} else {query.setParameter(idAttributeNames.iterator().next(),id);}return query.getSingleResult() == 1L;} else {return findOne(id) != null;}}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaRepository#findAll() */public List<T> findAll() {return getQuery(null, (Sort) null).getResultList();}/** (non-Javadoc)* @seeorg.springframework.data.repository.CrudRepository#findAll(ID[]) */public List<T> findAll(Iterable<ID> ids) {return getQuery(new Specification<T>() {public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {Path<?> path =root.get(entityInformation.getIdAttribute());return path.in(cb.parameter(Iterable.class, "ids"));}}, (Sort) null).setParameter("ids", ids).getResultList();}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaRepository#findAll(org.sp ringframework.data.domain.Sort)*/public List<T> findAll(Sort sort) {return getQuery(null, sort).getResultList();}/** (non-Javadoc)* @seeorg.springframework.data.repository.PagingAndSortingRepository#findA ll(org.springframework.data.domain.Pageable)*/public Page<T> findAll(Pageable pageable) {if (null == pageable) {return new PageImpl<T>(findAll());}return findAll(null, pageable);}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaSpecificationExecutor#fin dOne(org.springframework.data.jpa.domain.Specification) */public T findOne(Specification<T> spec) {try {return getQuery(spec, (Sort) null).getSingleResult();} catch (NoResultException e) {return null;}}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaSpecificationExecutor#fin dAll(org.springframework.data.jpa.domain.Specification) */public List<T> findAll(Specification<T> spec) {return getQuery(spec, (Sort) null).getResultList();}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaSpecificationExecutor#fin dAll(org.springframework.data.jpa.domain.Specification,org.springframework.data.domain.Pageable)*/public Page<T> findAll(Specification<T> spec, Pageable pageable) {TypedQuery<T> query = getQuery(spec, pageable);return pageable == null? new PageImpl<T>(query.getResultList()) : readPage(query, pageable, spec);}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaSpecificationExecutor#fin dAll(org.springframework.data.jpa.domain.Specification,org.springframework.data.domain.Sort)*/public List<T> findAll(Specification<T> spec, Sort sort) {return getQuery(spec, sort).getResultList();}/** (non-Javadoc)* @see org.springframework.data.repository.CrudRepository#count() */public long count() {return em.createQuery(getCountQueryString(),Long.class).getSingleResult();}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaSpecificationExecutor#cou nt(org.springframework.data.jpa.domain.Specification)*/public long count(Specification<T> spec) {return getCountQuery(spec).getSingleResult();}/** (non-Javadoc)* @seeorg.springframework.data.repository.CrudRepository#save(ng.Ob ject)*/@Transactionalpublic <S extends T> S save(S entity) {if (entityInformation.isNew(entity)) {em.persist(entity);return entity;} else {return em.merge(entity);}}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaRepository#saveAndFlush(j ng.Object)*/@Transactionalpublic T saveAndFlush(T entity) {T result = save(entity);flush();return result;}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaRepository#save(ng .Iterable)*/@Transactionalpublic <S extends T> List<S> save(Iterable<S> entities) { List<S> result = new ArrayList<S>();if (entities == null) {return result;}for (S entity : entities) {result.add(save(entity));}return result;}/** (non-Javadoc)* @seeorg.springframework.data.jpa.repository.JpaRepository#flush() */@Transactionalpublic void flush() {em.flush();}/*** Reads the given {@link TypedQuery} into a {@link Page} applying the given {@link Pageable} and* {@link Specification}.** @param query must not be {@literal null}.* @param spec can be {@literal null}.* @param pageable can be {@literal null}.* @return*/private Page<T> readPage(TypedQuery<T> query, Pageable pageable, Specification<T> spec) {query.setFirstResult(pageable.getOffset());query.setMaxResults(pageable.getPageSize());Long total = QueryUtils.executeCountQuery(getCountQuery(spec));List<T> content = total > pageable.getOffset() ?query.getResultList() : Collections.<T> emptyList();return new PageImpl<T>(content, pageable, total);}/*** Creates a new {@link TypedQuery} from the given {@link Specification}.** @param spec can be {@literal null}.* @param pageable can be {@literal null}.* @return*/private TypedQuery<T> getQuery(Specification<T> spec, Pageable pageable) {Sort sort = pageable == null ? null : pageable.getSort();return getQuery(spec, sort);}/*** Creates a {@link TypedQuery}for the given {@link Specification} and {@link Sort}.** @param spec can be {@literal null}.* @param sort can be {@literal null}.* @return*/private TypedQuery<T> getQuery(Specification<T> spec, Sort sort) {CriteriaBuilder builder = em.getCriteriaBuilder();CriteriaQuery<T> query = builder.createQuery(getDomainClass());Root<T> root = applySpecificationToCriteria(spec, query);query.select(root);if (sort != null) {query.orderBy(toOrders(sort, root, builder));}return applyLockMode(em.createQuery(query));}/*** Creates a new count query for the given {@link Specification}.** @param spec can be {@literal null}.* @return*/private TypedQuery<Long> getCountQuery(Specification<T> spec) {CriteriaBuilder builder = em.getCriteriaBuilder();CriteriaQuery<Long> query = builder.createQuery(Long.class);Root<T> root = applySpecificationToCriteria(spec, query);if (query.isDistinct()) {query.select(builder.countDistinct(root));} else {query.select(builder.count(root));}return em.createQuery(query);}/*** Applies the given {@link Specification} to the given {@link CriteriaQuery}.** @param spec can be {@literal null}.* @param query must not be {@literal null}.* @return*/private <S> Root<T> applySpecificationToCriteria(Specification<T> spec, CriteriaQuery<S> query) {Assert.notNull(query);Root<T> root = query.from(getDomainClass());if (spec == null) {return root;}CriteriaBuilder builder = em.getCriteriaBuilder();Predicate predicate = spec.toPredicate(root, query, builder);if (predicate != null) {query.where(predicate);}return root;}private TypedQuery<T> applyLockMode(TypedQuery<T> query) {LockModeType type = lockMetadataProvider == null ? null : lockMetadataProvider.getLockModeType();return type == null ? query : query.setLockMode(type);}}当然除了这些jpa自己的实现，我们也可以自己来实现一些复杂的逻辑算法：JpaRepository支持接口规范方法名查询：根据方法名，jpa会自动封装SQL语句，进行数据库操作，但使用时要注意两个问题：1.方法名需要在接口中命名；2.必须符合一定的命名规范这些资料可以去网上找：很多。

springdata+redis配置详解

springdata+redis配置详解springdata设计初衷是位简化数据类型和数据的持久化存储，它并不局限是关系型数据库还是nosql数据库，都提供了简化的数据库连接，让数据获取变得更加的简单。

所有这些的实现有统⼀的api提供。

本⽂主要设置spring-data-redis的相关配置特性：1.RedisTemplate:⾼度封装的，⾃动连接池管理类;2.对数据类型进⾏了归类，封装了操作接⼝类： a) ValueOperations:key-value操作 b) setOperations:set的相关操作 c) ZsetOperations: d) HashOperations:hash数据类型操作 e) ListOperations:list数据类型操作3.对事务进⾏封装，通过容器进⾏控制。

4.序列化机制，提供各种序列化策略选择。

集成配置详解： 1.提供简单封装保存查询操作接⼝，以及实现类。

1public interface RedisCommand {23public void save(String key,String value);45public String get(String key);67public <T> T getObject(String key,Class<T> clazz);89 }View Code1 @Service2public class RedisHandle implements RedisCommand {34 @Autowired5protected RedisTemplate<String, String> redisTemplate;67 @Override8public void save(final String key, final String value) {9 redisTemplate.execute(new RedisCallback<Object>() {10 @Override11public Object doInRedis(RedisConnection connection)12throws DataAccessException {13 connection.set(14 redisTemplate.getStringSerializer().serialize(15 "user.uid." + key), redisTemplate16 .getStringSerializer().serialize(value));17return null;18 }19 });20 }2122 @Override23public String get(final String key) {24return redisTemplate.execute(new RedisCallback<String>() {25 @Override26public String doInRedis(RedisConnection connection)27throws DataAccessException {28byte[] keys = redisTemplate.getStringSerializer().serialize(29 "user.uid." + key);30if (connection.exists(keys)) {31byte[] value = connection.get(keys);32 String name = redisTemplate.getStringSerializer()33 .deserialize(value);34return name;35 }36return null;37 }38 });39 }4041 @Override42public <T> T getObject(String key, Class<T> clazz) {43// TODO Auto-generated method stub44return null;45 }464748 }View Code 2.业务逻辑类1 @Service(value="userRedis")2public class UserRedisImpl implements UserRedis{34 @Autowired5protected RedisHandle handler;67 @Override8public void saveUser(final User user) {9 handler.save(user.getId()+"", JSONObject.toJSONString(user));10 }1112 @Override13public User getUser(final long id) {14 String value =handler.get(id+"");15 User u= JSONObject.parseObject(value, User.class);16return u;17 }18 }View Code 3.测试类：1public class TestUseRedis {23 @SuppressWarnings("resource")4public static void main(String[] args) {5 ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:/spring-redis.xml");6 UserRedis userDAO = (UserRedis)ac.getBean("userRedis");7 System.out.println("userDao"+JSONObject.toJSONString(userDAO));8 User user1 = new User();9 user1.setId(4);10 user1.setName("oba2sssss220a");11 userDAO.saveUser(user1);12 User user2 = userDAO.getUser(2);13 System.out.println(user2.getName());14 }15 }View Code 4.配置⽂件相关：spring-redis:1 <?xml version="1.0" encoding="UTF-8"?>2 <beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"4 xmlns:context="/schema/context"5 xmlns:jee="/schema/jee" xmlns:tx="/schema/tx"6 xmlns:aop="/schema/aop"7 xsi:schemaLocation="8 /schema/beans /schema/beans/spring-beans.xsd9 /schema/context /schema/context/spring-context.xsd"> 1011 <context:property-placeholder location="classpath:redis.properties" />12 <context:component-scan base-package="com.hoo.report.web.service">13 </context:component-scan>14 <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">15 <property name="maxIdle" value="${redis.maxIdle}" />16 <property name="maxActive" value="${redis.maxActive}" />17 <property name="maxWait" value="${redis.maxWait}" />18 <property name="testOnBorrow" value="${redis.testOnBorrow}" />19 </bean>2021 <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"22 p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/> 2324 <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">25 <property name="connectionFactory" ref="connectionFactory" />26 </bean>2728 </beans>View Codepom引⽤：1 2 <dependency>3 <groupId>org.springframework.data</groupId>4 <artifactId>spring-data-redis</artifactId>5 <version>1.0.2.RELEASE</version>6 </dependency>78 <dependency>9 <groupId>redis.clients</groupId>10 <artifactId>jedis</artifactId>11 <version>2.1.0</version>12 </dependency>View Coderedis.properties:1 redis.host=127.0.0.12 redis.port=63793 redis.pass=45 redis.maxIdle=3006 redis.maxActive=6007 redis.maxWait=10008 redis.testOnBorrow=trueView Code。

SpringDataJPA，一种动态条件查询的写法

SpringDataJPA，⼀种动态条件查询的写法我们在使⽤SpringData JPA框架时，进⾏条件查询，如果是固定条件的查询，我们可以使⽤符合框架规则的⾃定义⽅法以及@Query注解实现。

如果是查询条件是动态的，框架也提供了查询接⼝。

JpaSpecificationExecutor和其他接⼝使⽤⽅式⼀样，只需要在你的Dao接⼝继承即可(官⽹代码)。

public interface CustomerRepository extends CrudRepository<Customer, Long>, JpaSpecificationExecutor {…}JpaSpecificationExecutor提供很多条件查询⽅法。

public interface JpaSpecificationExecutor<T> {T findOne(Specification<T> var1);List<T> findAll(Specification<T> var1);Page<T> findAll(Specification<T> var1, Pageable var2);List<T> findAll(Specification<T> var1, Sort var2);long count(Specification<T> var1);}⽐如⽅法:List<T> findAll(Specification<T> var1);就可以查找出符合条件的所有数据，如果你的框架使⽤的是前段分页的技术，那么这个⽅法就挺简便的。

那么这个⽅法该如何使⽤呢？我们看到它需要的参数是⼀个org.springframework.data.jpa.domain.Specification对象。

SpringDataJPA在Entity中常用的注解浅析

SpringDataJPA在Entity中常⽤的注解浅析⾸先我们常⽤的注解包括(@Entity、@Table、@Id、@IdClass、@GeneratedValue、@Basic、@Transient、@Column、@Temporal、@Enumerated、@Lob)1. @Entity使⽤此注解定义的对象将会成为被JPA管理的实体，将映射到指定的数据库表@Entity(name = "user")其中name默认是此实体类的名字，全局唯⼀。

2. @Table指定此实体类对应的数据库的表名。

若注解不加名字则系统认为表名和实体类的名字相同3. @Id定义字段为数据库的主键，⼀个实体⾥⾯必须有⼀个。

4. @IdClass利⽤外部类的联合主键，其中外部类必须满⾜⼀下⼏点要求必须实现Serializable接⼝。

必须有默认的public⽆参数的构造⽅法。

必须覆盖equals和hashCode⽅法。

equals⽅法⽤于判断两个对象是否相同，EntityManger通过find⽅法来查找Entity时是根据equals的返回值来判断的。

hashCode⽅法返回当前对象的哈希码，⽣成的hashCode相同的概率越⼩越好，算法可以进⾏优化。

5. @GeneratedValue为主键⽣成策略默认为AUTO即JPA⾃动选择合适的策略IDENTITY 适⽤于MySQL，策略为⾃增SEQUENCE 通过序列⽣成主键通过@SquenceGenerator指定序列名MySQL不⽀持TABLE 框架由表模拟产⽣主键，使⽤该策略有利于数据库移植6. @Basic表⽰此字段是映射到数据库，如果实体字段上没有任何注解默认为@Basic。

其中可选参数为@Basic(fetch = ZY, optional = false)其中fetch默认为EAGER⽴即加载，LAZY为延迟加载、optional表⽰该字段是否可以为null7. @Transient和@Basic的作⽤相反，表⽰该字段不是⼀个到数据库表的字段映射，JPA映射数据库的时候忽略此字段。

SpringData与MyBatis的比较和选择

SpringData与MyBatis的比较和选择在Java开发领域，SpringData和MyBatis都是非常受欢迎的持久化框架。

它们都有自己独特的特点和优势，但也存在一些不同之处。

本文将对这两个框架进行比较，帮助开发者选择适合自己项目需求的框架。

1. 简介SpringData是由Spring框架提供的一个用于简化数据库访问的基础架构。

它整合了现有的持久化框架（如JPA、Hibernate、MyBatis等），为开发者提供了一种统一的方式来操作数据库。

而MyBatis则是一个持久化框架，它通过SQL映射文件将Java对象与数据库表进行映射。

2. 功能特点2.1 SpringDataSpringData提供了一套丰富的API，支持多种数据库访问方式，包括关系型数据库、NoSQL数据库以及搜索引擎。

它具有自动生成SQL语句、分页查询、事务管理等功能，并提供了一些常用查询方法的实现，减少了开发者的工作量。

2.2 MyBatisMyBatis是一个轻量级的持久化框架，它与数据库之间的交互主要通过手写的SQL语句。

MyBatis的主要特点是灵活性和可控性，开发者可以根据需求自由编写SQL，优化查询性能。

此外，MyBatis还支持一级、二级缓存，提高了查询的效率。

3. 使用场景3.1 SpringDataSpringData适用于对数据库操作较为简单的场景，对于增删改查等基本操作，SpringData提供了一些默认实现，可以快速完成开发。

同时，SpringData也支持动态查询、排序、分页等高级查询功能，能够满足大部分常见的需求。

3.2 MyBatisMyBatis适用于对数据库操作较为复杂、SQL定制化要求较高的场景。

由于MyBatis将SQL与Java代码分离，开发者完全可以根据需求优化SQL语句，提高查询效率。

此外，MyBatis的一级、二级缓存也适用于对查询性能有较高要求的场景。

4. 性能比较4.1 SpringData由于SpringData是一个整合了多种持久化框架的库，它的性能往往受到具体框架的影响。

Spring集成Redis方案（spring-data-redis）（基于Jedis的单机。。。

Spring集成Redis⽅案（spring-data-redis）（基于Jedis的单机。

说明：请注意Spring Data Redis的版本以及Spring的版本！最新版本的Spring Data Redis已经去除Jedis的依赖包，需要⾃⾏引⼊，这个是个坑点。

并且会与⼀些低版本的Spring有冲突，要看官⽅⽂档和不断的测试。

继上⼀篇⽂章中提到的⼏款客户端，它们基本都能和Spring集成。

下⾯介绍的是基于Spring原⽣的spring-data-redis去集成。

还要注意的是，Spring整合了Jedis框架进去，所以下⾯配置上还会基于Jedis去实现的，但是Spring在上层已经集成了很好⽤的⼯具类。

⽽整个框架基于Spring Data，⾥⾯集成了主流的应⽤，⽐如Redis，MongoDB等，⽽基于这些应⽤的⼀些⾮常好⽤的框架也集成了，⽐如Jedis这些。

我猜测，基于Spring Data Redis去集成的，底层还是⽤Jedis去实现，应该是可以实现客户端集群的，下次我再实践详细分析⼀下。

Spring Data Redis项⽬结构：POM：<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.x.redis</groupId><artifactId>Spring_redis</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><name>Spring_redis</name><url></url><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-redis</artifactId><version>1.0.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.1.0</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.8.2</version><scope>test</scope></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.6.1</version></dependency><!-- 将现有的jakarta commons logging的调⽤转换成lsf4j的调⽤。

Spring Data JPA快速使用

Spring Data JPA快速启动目录Spring Data JPA快速启动 (1)1概述 (1)2 Spring Data JPA使用 (1)2.1实体类规范： (2)2.2 Dao接口规范： (2)2.3 自定义查询 (4)2.4 配置文件规范 (7)2.5事务处理 (9)2.6 为接口中的部分方法提供自定义实现 (12)2.7 锁 (13)2.8 应用场景以及优点 (15)2.9 JPA的缺陷: (16)1概述Spring Data JPA 是Spring Data 家族的提供的一个持久层框架，可以自动创建dao实现类和自定义查询，简化了持久层代码。

2 Spring Data JPA使用使用Spring Data JPA只需要3个步骤：(1)声明持久层的接口，该接口继承 Repository，Repository 是一个标记型接口，它不包含任何方法，当然如果有需要，Spring Data 也提供了若干 Repository 子接口，其中定义了一些常用的增删改查，以及分页相关的方法。

(2)在接口中声明需要的业务方法。

Spring Data 将根据给定的策略来为其生成实现代码。

(3)在 Spring 配置文件中增加一行声明，让 Spring 为声明的接口创建代理对象。

配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

此外，<jpa:repository> 还提供了一些属性和子标签，便于做更细粒度的控制。

可以在<jpa:repository> 内部使用<context:include-filter>、<context:exclude-filter> 来过滤掉一些不希望被扫描到的接口。

dao层继承jparepository怎么用_浅析SpringDataJpa继承结构

dao层继承jparepository怎么用_浅析SpringDataJpa继承结构Spring Data JPA 是 Spring 提供的一个用于简化持久层操作的框架，它支持继承结构来进行数据库操作。

在 Spring Data JPA 中，我们通常使用 `JpaRepository` 接口作为 DAO 层的基础接口，其他的 DAO 接口则继承自 `JpaRepository` 来获得基本的 CRUD 操作。

`JpaRepository` 是 Spring Data JPA 提供的一个基础仓库接口，它继承自 `PagingAndSortingRepository` 接口和 `CrudRepository` 接口。

通过继承 `JpaRepository` 接口，我们可以直接使用其中定义的一些常用方法，无需自己去实现。

首先，我们需要定义一个 DAO 接口，并继承 `JpaRepository`，如下所示：```javapublic interface UserDao extends JpaRepository<User, Long>//可以自定义一些查询方法User findByUsername(String username);```在上面的例子中，我们定义了一个 `UserDao` 接口，继承自`JpaRepository<User, Long>`，其中 `User` 是实体类的类型，而`Long` 是实体类的主键类型。

通过继承 `JpaRepository` 接口，`UserDao` 接口中就已经获得了一些常用的方法，比如 `findAll(`、`save(`、`delete(`等。

而且，我们还可以根据自己的需要在 `UserDao` 接口中自定义一些查询方法，如上面的 `findByUsername(` 方法。

当我们需要在其他DAO接口中使用这些继承的方法时，只需要继承自定义的DAO接口即可，如下所示：```javapublic interface OrderDao extends UserDao//根据用户ID查询订单列表List<Order> findByUserId(Long userId);```在上面的例子中，我们定义了一个 `OrderDao` 接口，继承自`UserDao` 接口。

SpringDataJpa使用原生sql（EntityManager）动态拼接,分页查询

SpringDataJpa使⽤原⽣sql（EntityManager）动态拼接,分页查询SpringDataJpaSpring Data JPA是较⼤的Spring Data系列的⼀部分，可轻松实现基于JPA的存储库。

该模块处理对基于JPA的数据访问层的增强⽀持。

它使构建使⽤数据访问技术的Spring⽀持的应⽤程序变得更加容易。

实现应⽤程序的数据访问层已经很长⼀段时间了。

为了执⾏简单查询以及执⾏分页和审核，必须编写太多样板代码。

Spring Data JPA旨在通过将⼯作量减少到实际需要的数量来显着改善数据访问层的实现。

作为开发⼈员，您将编写包括⾃定义finder⽅法在内的存储库接⼝，Spring会⾃动提供实现。

使⽤EntityManager 来创建原⽣查询语句在service层的代码:@PersistenceContextEntityManager entityManager;@Overridepublic Object findMeetingSignRecoredPage(Long meetingId, Integer pageIndex, Integer pageSize) {MeenoAssert.notNull(meetingId, ErrEnum.MEETING_ID_IS_EMPTY);Meeting meeting = this.meetingRepository.getOne(meetingId);MeenoAssert.notNull(meeting,ErrEnum.MEETING_IS_NOT_EXIST);Pageable pageable = PageUtils.getPageable(pageIndex,pageSize);StringBuilder sql = new StringBuilder();sql.append(" select ,MAX(r.sign) from mnt_emp_rel_meeting as e ");sql.append(" left join mnt_sign_record as r on(r.employee_id=e.employee_id) ");sql.append(" left join mnt_employee as ep on(ep.id = e.employee_id) ");sql.append(" where e.meeting_id = ? ");sql.append(" order by r.sign desc,r.create_date asc ");Query query = entityManager.createNativeQuery(sql.toString());query.setFirstResult(pageable.getOffset());query.setMaxResults(pageable.getPageSize());query.setParameter(1,meetingId);List<Object[]> list = query.getResultList();List<SignRecordView> listView = Lists.newArrayList();if(list != null && !list.isEmpty()){for (Object[] objects : list) {String empName = objects[0]==null?null:objects[0].toString();Integer sign = objects[1]==null?Constants.SIGN_RECORD_NO:Integer.parseInt(objects[1].toString());SignRecordView view = new SignRecordView();view.setEmployeeName(empName);view.setSign(sign);listView.add(view);}}//countStringBuilder countSql = new StringBuilder();countSql.append(" select count(distinct e.id) from mnt_emp_rel_meeting as e ");countSql.append(" left join mnt_sign_record as r on(r.employee_id=e.employee_id) ");countSql.append(" left join mnt_employee as ep on(ep.id = e.employee_id) ");countSql.append(" where e.meeting_id = ? ");countSql.append(" order by r.sign desc,r.create_date asc ");Query countQuery = entityManager.createNativeQuery(countSql.toString());countQuery.setParameter(1,meetingId);Object singleResult = countQuery.getResultList().get(0);Integer count = singleResult==null?0:Integer.valueOf(singleResult.toString());Map<String, Object> resultPage = PageUtils.getResultPage(count, listView);return resultPage;}PageUtils⼯具类代码如下:package com.meeno.framework.page.utils;import mon.collect.Lists;import mon.collect.Maps;import lombok.Data;import org.springframework.data.domain.Page;import org.springframework.data.domain.PageRequest;import org.springframework.data.domain.Pageable;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Map;/*** @description: 分页⼯具类* @author: Wzq* @create: 2019-12-26 20:19*/@Datapublic class PageUtils {/***@Description 获取集合分页对象*@Param [list, pageIndex, pageSize]*@Return void*@Author Wzq*@Date 2020/1/6*@Time 14:07*/public static <T> Map<String,Object> getCollectionPage(List<T> list, Pageable pageable){ if(list==null||list.isEmpty()){return PageUtils.getResultPage(0,null );}int offset = pageable.getOffset();int pageSize = pageable.getPageSize();List<T> listView = Lists.newArrayList();if(list!=null && !list.isEmpty()){if(list.size() < offset){return PageUtils.getResultPage(0,null );}for(;list.size() > offset && pageSize != 0 ; offset++,pageSize--){listView.add(list.get(offset));}return PageUtils.getResultPage(list.size(),listView);}return PageUtils.getResultPage(0,null );}/***@Description 根据pageIndex和pageSize获取Pageable*@Param [pageIndex, pageSize]*@Return org.springframework.data.domain.Pageable*@Author Wzq*@Date 2019/12/27*@Time 11:12*/public static Pageable getPageable(Integer pageIndex, Integer pageSize){if(pageIndex==null){pageIndex = 0;}else{pageIndex--;}if(pageSize==null){pageSize = 10;}PageRequest pageRequest = new PageRequest(pageIndex, pageSize);return pageRequest;}/***@Description 获取分页返回对象*@Param [totalCount, list]*@Return java.util.Map<ng.String,ng.Object>*@Author Wzq*@Date 2019/12/26*@Time 20:22*/public static Map<String,Object> getResultPage(Page<?> page, List<?> list){ Map<String,Object> resultPageMap = Maps.newHashMap();resultPageMap.put("totalCount",page.getTotalElements());resultPageMap.put("list",list);return resultPageMap;}public static Map<String,Object> getResultPage(Integer count, List<?> list){ Map<String,Object> resultPageMap = Maps.newHashMap();resultPageMap.put("totalCount",count);resultPageMap.put("list",list);return resultPageMap;}}。

spring－data－redis序列化实践笔记

spring－data－redis序列化实践笔记（⼀）spring data redis 提供了多种可选择策略(RedisSerializer)JdkSerializationRedisSerializer：POJO对象的存取场景，使⽤JDK本⾝序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进⾏序列化操作，最终redis-server中将存储字节序列。

是⽬前最常⽤的序列化策略。

StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。

是最轻量级和⾼效的策略。

JacksonJsonRedisSerializer：jackson-json⼯具提供了javabean与json之间的转换能⼒，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。

因为jackson ⼯具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。

【需要jackson-mapper-asl⼯具⽀持】OxmSerializer：提供了将javabean与xml之间的转换能⼒，⽬前可⽤的三⽅⽀持包括jaxb，apache-xmlbeans；redis存储的数据将是xml⼯具。

不过使⽤此策略，编程将会有些难度，⽽且效率最低；不建议使⽤。

【需要spring-oxm模块的⽀持】（出⾃：）spring-data-redis提供了多种serializer策略，这对使⽤jedis的开发者⽽⾔，实在是⾮常便捷。

sdr提供了4种内置的serializer：JdkSerializationRedisSerializer：使⽤JDK的序列化⼿段(serializable接⼝，ObjectInputStrean，ObjectOutputStream)，数据以字节流存储StringRedisSerializer：字符串编码，数据以string存储JacksonJsonRedisSerializer：json格式存储OxmSerializer：xml格式存储其中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的序列化策略，其中“JacksonJsonRedisSerializer”与“OxmSerializer”都是基于stirng存储，因此它们是较为“⾼级”的序列化(最终还是使⽤string解析以及构建java对象)。

Spring Data MongoDB查询指南

Spring Data MongoDB 查询指南Spring Data MongoDB 中的查询指南1. 概述本文将关注在Spring Data MongoDB 中构建不同类型的查询。

我们将查看使用Query 和Criteria 类查询ducument、自动生成的查询方法、JSON 查询和QueryDSL。

1.1. Maven 依赖如果你希望使用Spring Data MongoDB，你需要加入以下条目到你的pom.xml 文件：<dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-mongodb</artifactId><version>1.9.6.RELEASE</version></dependency>最新版本可以在这里找到。

2. Document 查询使用Spring Data 查询MongoDB的一种常见方法是使用Query 和Criteria 类，它们非常接近原生操作。

2.1. is这只是一个使用相等的criterion，让我们看看它是如何工作的。

在以下示例中，我们查找名为Eric 的用户。

让我来看看我们的数据库：[{"_id" : ObjectId("55c0e5e5511f0a164a581907"),"_class" : "er","name" : "Eric","age" : 45},{"_id" : ObjectId("55c0e5e5511f0a164a581908"),"_class" : "er","name" : "Antony","age" : 55}]现在让我们看一下查询代码：Query query = new Query();query.addCriteria(Criteria.where("name").is("Eric"));List<User> users = mongoTemplate.find(query, User.class);该逻辑的返回值将如预期：{"_id" : ObjectId("55c0e5e5511f0a164a581907"),"_class" : "er","name" : "Eric","age" : 45}2.2. 正则表达式正则表达式是一种更灵活、更强大的查询类型。

Spring-data-jpa笔记（二）Repository详解

Spring-data-jpa笔记（⼆）Repository详解基础的 Repository 提供了最基本的数据访问功能，其⼏个⼦接⼝则扩展了⼀些功能。

它们的继承关系如下：Repository：是 spring Data 的⼀个核⼼接⼝，它不提供任何⽅法，开发者需要在⾃⼰定义的接⼝中声明需要的⽅法仅仅是⼀个标识，表明任何继承它的均为仓库接⼝类，⽅便Spring⾃动扫描识别,@Indexedpublic interface Repository<T, ID> {}T ：实体类名 ID : 主键类型CrudRepository：继承 Repository，实现了⼀组 CRUD 相关的⽅法@NoRepositoryBeanpublic interface CrudRepository<T, ID> extends Repository<T, ID> {<S extends T> S save(S entity);<S extends T> Iterable<S> saveAll(Iterable<S> entities);Optional<T> findById(ID id);boolean existsById(ID id);Iterable<T> findAll();Iterable<T> findAllById(Iterable<ID> ids);long count();void deleteById(ID id);void delete(T entity);void deleteAll(Iterable<? extends T> entities);void deleteAll();}PagingAndSortingRepository：继承 CrudRepository，实现了⼀组分页排序相关的⽅法public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID>Iterable<T> findAll(Sort sort);Page<T> findAll(Pageable pageable);}使⽤举例：如果要在以20为⼀页的结果中，获取第2页结果，则如下使⽤：Page<User> users = repository.findAll(new PageRequest(1, 20));JpaRepository：继承 PagingAndSortingRepository，实现⼀组 JPA 规范相关的⽅法⾃定义的 XxxxRepository 需要继承 JpaRepository，这样的 XxxxRepository 接⼝就具备了通⽤的数据访问控制层的能⼒。

5-Spring-Boot(五)：spring data jpa的使用

在上篇文章springboot(二)：web综合开发中简单介绍了一下spring data jpa 的基础性使用，这篇文章将更加全面的介绍spring data jpa 常见用法以及注意事项使用spring data jpa 开发时，发现国内对spring boot jpa全面介绍的文章比较少案例也比较零碎，因此写文章总结一下。

本人也正在翻译Spring Data JPA 参考指南,有兴趣的同学欢迎联系我，一起加入翻译中！spring data jpa介绍首先了解JPA是什么？JPA(Java Persistence API)是Sun官方提出的Java持久化规范。

它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。

他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。

值得注意的是，JPA是在充分吸收了现有Hibernate，TopLink，JDO等ORM框架的基础上发展而来的，具有易于使用，伸缩性强等优点。

从目前的开发社区的反应上看，JPA受到了极大的支持和赞扬，其中就包括了Spring与EJB3.0的开发团队。

注意:JPA是一套规范，不是一套产品，那么像Hibernate,TopLink,JDO他们是一套产品，如果说这些产品实现了这个JPA规范，那么我们就可以叫他们为JPA的实现产品。

spring data jpaSpring Data JPA 是Spring 基于ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。

它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用Spring Data JPA 可以极大提高开发效率！spring data jpa让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现基本查询基本查询也分为两种，一种是spring data默认已经实现，一种是根据查询的方法来自动解析成SQL。

如何使用Spring Data对数据进行管理,提高数据管理效率

如何使用Spring Data对数据进行管理，提高数据管理效率随着互联网和云计算技术的发展，数据管理已经成为企业最重要的工作之一。

数据管理对于企业而言，是保持竞争优势和增长的关键。

那么如何精准、高效、可靠地管理数据呢？这就需要我们使用Spring Data对数据进行管理。

Spring是一个开源框架，提供了丰富的Java开发工具和API，简化了Java 应用程序的开发和部署过程。

Spring Data是Spring提供的扩展功能，它可以帮助我们更好地管理数据，提高数据管理效率。

Spring Data的主要功能有以下几个方面：1. 数据访问层的开发2. 数据库连接和事务管理3. NoSQL数据库的支持4. 数据库版本控制5. 数据库集群的支持下面我们来详细介绍Spring Data的使用方法。

一、数据访问层的开发Spring Data可以帮助我们开发数据访问层（DAO）。

DAO是数据访问对象的缩写，它是用来访问数据库的，Spring Data通过提供一套通用的数据访问API，帮助我们轻松地开发DAO。

使用Spring Data，我们可以通过定义Java接口来访问数据，而不需要手动编写SQL语句。

比如我们可以定义一个UserRepository接口，然后在接口中定义各种查询方法，如findByUsername和findByEmail。

@Repositorypublic interface UserRepository extends JpaRepository<User, Long> {User findByUsername(String username);User findByEmail(String email);}在上面的例子中，@Repository注解表示UserRepository是一个仓库，@JpaRepository注解表示这个仓库使用JPA进行数据访问。

findByUsername和findByEmail是两个查询方法，只需要在方法名中加上findBy，然后紧跟着被查询的属性名，就可以快速定义查询方法。

SpringDataJPA中@OneToMany和@ManyToOne的用法详解

SpringDataJPA中@OneToMany和@ManyToOne的⽤法详解⽬录⼀. 假设需求场景⼆. 代码实现2.1 级联存储操作2.2 查询操作和toSting问题2.3 级联删除2.4 pom.xml⼀. 假设需求场景在我们开发的过程中，经常出现两个对象存在⼀对多或多对⼀的关系。

如何在程序在表明这两个对象的关系，以及如何利⽤这种关系优雅地使⽤它们。

其实，在javax.persistence包下有这样两个注解——@OneTomany和@ManyToOne，可以为我们所⽤。

现在，我们假设需要开发⼀个校园管理系统，管理各⼤⾼校的学⽣。

这是⼀种典型的⼀对多场景，学校和学⽣的关系。

这⾥，我们涉及简单的级联保存，查询，删除。

⼆. 代码实现2.1 级联存储操作Student类和School类@Data@Table@Entity@Accessors(chain = true)public class Student {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;private String name;@ManyToOne@JoinColumn(name = "school_fk")private School school;}Student类上⾯的四个注解不做解释，id主键使⽤⾃增策略。

Student中有个School的实例变量school，表明学⽣所属的学校。

@ManyToOne（多对⼀注解）代表在学⽣和学校关系中“多”的那⽅，学⽣是“多”的那⽅，所以在Student类⾥⾯使⽤@ManyToOne。

那么，@ManyToOne中One当然是指学校了，也就是School类。

@JoinColumn(name = “school_fk”)指明School类的主键id在student表中的字段名，如果此注解不存在，⽣成的student表如下：@Data@Table@Entity@Accessors(chain = true)public class School {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Integer id;private String name;@OneToMany(mappedBy="school"，cascade = CascadeType.PERSIST)private List<Student> students;}在School类中，维护⼀个类型为List的students实例变量。

Spring的datasource配置详解【转】

Spring的datasource配置详解【转】⼀句话，Spring对Hibernate的整合，是在applicationContext.xml中配置sessionFactory来实现的，其中sessionFactory中要装配dataSource。

下⾯就详细介绍dataSource Bean的配置。

SessionFactory接⼝负责初始化Hibernate。

它充当数据存储源的代理，并负责创建Session对象。

这⾥⽤到了⼯⼚模式。

需要注意的是SessionFactory 并不是轻量级的，因为⼀般情况下，⼀个项⽬通常只需要⼀个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定⼀个SessionFactory。

实际上它的设计者的意图是让它能在整个应⽤中共享。

SessionFactory在中实际起到了⼀个缓冲区的作⽤，它缓冲了Hibernate⾃动⽣成的SQL语句和⼀些其它的映射数据，还缓冲了⼀些将来有可能重复利⽤的数据。

session是由sessionfactory来创建，可以创建很多session。

Session 接⼝对于Hibernate 开发⼈员来说是⼀个最重要的接⼝。

在Hibernate的设计者的头脑中，他们将session看作介于数据连接与事务管理⼀种中间接⼝。

我们可以将session想象成⼀个持久对象的缓冲区，Hibernate能检测到这些持久对象的改变，并及时刷新数据库。

我们有时也称Session是⼀个持久层管理器，因为它包含这⼀些持久层相关的操作，诸如存储持久对象⾄数据库，以及从数据库从获得它们。

datasource数据源是注⼊给sessionfactory的，然后关联到session中。

先上代码（⽐较齐全的属性）：<bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName" value="${driverClassName}" /><property name="url" value="${url}" /><property name="username" value="${username}" /><property name="password" value="${password}" /><property name="initialSize" value="${initialSize}" /><property name="maxActive" value="${maxActive}" /><property name="maxIdle" value="${maxIdle}" /><property name="minIdle" value="${minIdle}" /><property name="poolPreparedStatements" value="true" /><property name="defaultAutoCommit" value="true" /></bean>1.Bean的id为dataSource，对应的java类是BasicDataSource，这个类适⽤于配置基本类型的数据库连接，如果要想进⾏多数据源，那么该Bean对应的java类就得⽤DynamicDataSource。

SpringDataCommons官方文档学习

SpringDataCommons官⽅⽂档学习Spring Data Commons 官⽅⽂档学习 -byVersion 1.12.6.Release, 2017-07-27，带格式。

Table of Contents前⾔Spring Data Commons project 将core Spring concepts应⽤到了很多关系型和⾮关系型数据存储的解决⽅案开发。

参考⽂档1. 依赖由于Spring Data modules不同的开发时间，所以它们⼤多数都有不同的主版本号和⼩版本号。

想要找到兼容版本的最佳⽅式是依赖Spring Data Release Train BOM，已经提供了兼容版本定义。

在Maven项⽬中，你可以在POM的<dependencyManagement />部分声明该依赖：例⼦1. 使⽤Spring Data release train BOM1. <dependencyManagement>2. <dependencies>3. <dependency>4. <groupId>org.springframework.data</groupId>5. <artifactId>spring-data-releasetrain</artifactId>6. <version>${release-train}</version>7. <scope>import</scope>8. <type>pom</type>9. </dependency>10. </dependencies>11. </dependencyManagement>当前的release train版本是Ingalls-SR6。

SpringDataElasticsearch基本使用

SpringDataElasticsearch基本使⽤Spring Data Elasticsearch基本使⽤官⽹指南：1、maven依赖：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency>2.、配置application.yml⽂件# yml配置elasticsearch客户端地址（可配置项有限）spring:elasticsearch:rest:uris: http://192.168.220.101:9200 # elasticsearch 连接地址username: elastic # ⽤户名password: 123456 # 密码connection-timeout: 10s # 连接超时时间（默认1s）read-timeout: 30s # 数据读取超时时间（默认30s）# ⽅便查询发送的http请求详细内容logging:file:name: ./log/log.loglevel:root: infoorg.springframework.data.elasticsearch.client.WIRE: trace3. 实体类及注解/*** @Author dw* @ClassName User* @Description 实体映射** 注解说明* @Document：在类级别应⽤，以指⽰该类是映射到数据库的候选对象。

最重要的属性是：* indexName：⽤于存储此实体的索引的名称。

它可以包含SpEL模板表达式，例如 "log-#{T(java.time.LocalDate).now().toString()}"* type：映射类型。