Java经典框架之SpringDataJPA
SpringDataJPA
Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。
课程内容的介绍
1. Spring整合Hibernate
2. Spring整合HibernateJPA
3. SpringDataJPA介绍
4. SpringBoot整合SpringDataJPA
Spring Data JPA：Spring Data JPA 是 Spring Data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的。
Spring Data JPA 的技术特点：我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类。
一、Spring整合Hibernate
1. 创建项目
创建一个普通的Maven项目即可。
2.添加相关的依赖
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.2</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.8</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.11</version></dependency><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>5.0.7.Final</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.1.6.RELEASE</version></dependency></dependencies>3. 添加相关的配置文件
添加数据库的配置文件和Spring的配置文件。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd
"><!-- 引入db.properties文件 --><context:property-placeholder location="classpath:db.properties" /><!-- 创建druid 的数据源 --><bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource"><property name="url" value="${jdbc.url}" /><property name="driverClassName" value="${jdbc.driver}" /><property name="username" value="${jdbc.username}" /><property name="password" value="${jdbc.password}" /></bean><!-- 配置Hibernate的SessionFactory对象 --><bean class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" id="sessionFactory"><!-- 关联数据源 --><property name="dataSource" ref="dataSource"/><!-- 配置Hibernate的属性信息 --><property name="hibernateProperties"><props><prop key="show_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property><!-- 扫描路径 --><property name="packagesToScan"><list><value>com.bobo.pojo</value></list></property></bean><!-- 配置HibernateTemplate对象 --><bean class="org.springframework.orm.hibernate5.HibernateTemplate" id="hibernateTemplate"><property name="sessionFactory" ref="sessionFactory"/></bean><!-- 配置事务管理--><bean class="org.springframework.orm.hibernate5.HibernateTransactionManager" id="transactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><!-- 配置开启事务注解 --><tx:annotation-driven transaction-manager="transactionManager" /><!-- 配置扫描路径 --><context:component-scan base-package="com.bobo" />
</beans>4. 创建POJO
和表结构中的t_user表对应即可。
package com.bobo.pojo;import javax.persistence.*;
import java.io.Serializable;@Entity
@Table(name="t_user")
public class Users implements Serializable {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name="user_id")private Integer userId;@Column(name="user_name")private String userName;@Column(name="real_name")private String realName;public Integer getUserId() {return userId;}public void setUserId(Integer userId) {this.userId = userId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getRealName() {return realName;}public void setRealName(String realName) {this.realName = realName;}}
5. 创建持久层
定义持久层接口，定义要实现的相关的方法。
package com.bobo.dao;import com.bobo.pojo.Users;import java.util.List;public interface IUserDao {void insertUsers(Users users);void updateUsers(Users users);void deleteUsers(Users users);Users selectUsersById(Integer userId);List<Users> selectUsersByName(String userName);List<Users> selectUsersByNameUseSQL(String userName);List<Users> selectUsersByNameUseCriteria(String userName);
}
package com.bobo.dao.impl;import com.bobo.dao.IUserDao;
import com.bobo.pojo.Users;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;import java.util.List;@Repository
public class UserDaoImpl implements IUserDao {@Autowiredprivate HibernateTemplate template;@Overridepublic void insertUsers(Users users) {this.template.save(users);}@Overridepublic void updateUsers(Users users) {this.template.update(users);}@Overridepublic void deleteUsers(Users users) {this.template.delete(users);}@Overridepublic Users selectUsersById(Integer userId) {return this.template.get(Users.class,userId);}@Overridepublic List<Users> selectUsersByName(String userName) {// 我们要执行特殊的查询操作 我们需要获取对应的Session对象Session session = this.template.getSessionFactory().getCurrentSession();// 通过Session对象创建Query对象 HQL 语句Query query = session.createQuery(" from Users where userName = :abc");Query queryTemp = query.setString("abc", userName);return queryTemp.list();}@Overridepublic List<Users> selectUsersByNameUseSQL(String userName) {// 我们要执行特殊的查询操作 我们需要获取对应的Session对象Session session = this.template.getSessionFactory().getCurrentSession();// 通过Session对象创建Query对象 SQL 语句Query query = session.createSQLQuery("select * from t_user where user_name = ?").addEntity(Users.class).setString(0, userName);return query.list();}@Overridepublic List<Users> selectUsersByNameUseCriteria(String userName) {Session session = this.template.getSessionFactory().getCurrentSession();Criteria criteria = session.createCriteria(Users.class);criteria.add(Restrictions.eq("userName",userName));return criteria.list();}
}
6. 单元测试
package com.bobo.test;import com.bobo.dao.IUserDao;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test1 {@Autowiredprivate IUserDao dao;@Test@Transactional@Rollback(false)public void testInsertUser(){Users user = new Users();user.setUserName("Tom");user.setRealName("张三丰");dao.insertUsers(user);}@Test@Transactionalpublic void testQuery1(){Users users = this.dao.selectUsersById(22);System.out.println(users);}@Test@Transactionalpublic void testQuery2(){List<Users> list = this.dao.selectUsersByNameUseSQL("Tom");for (Users users : list) {System.out.println(users);}}}
二、Spring整合HibernateJPA
现如今的ORM框架还是比较多的比如Hibernate，TopLink以及OpenJPA等等，为了简化ORM框架的使用，JPA随之产生。
JPA是Java Persistence API的简称，中文名Java持久层API，由 Sun 公司提供了一对对于持久层操作的标准(接口+文档),说白了就是在各种ORM框架之上封装了一套API实现统一操作。同时又依赖各种ORM框架去实现。hibernate3.2版本后提供了对JPA的实现。
1. 创建项目
创建一个普通的Maven项目即可。
2. 添加相关的依赖
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.2</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.8</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.11</version></dependency><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-entitymanager</artifactId><version>5.0.7.Final</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.1.6.RELEASE</version></dependency></dependencies>3. 添加相关的配置文件
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/logistics?characterEncoding=utf-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456 Spring的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd
"><!-- 引入db.properties文件 --><context:property-placeholder location="classpath:db.properties" /><!-- 创建druid 的数据源 --><bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource"><property name="url" value="${jdbc.url}" /><property name="driverClassName" value="${jdbc.driver}" /><property name="username" value="${jdbc.username}" /><property name="password" value="${jdbc.password}" /></bean><!-- 配置Hibernate的SessionFactory对象 --><bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="sessionFactory"><!-- 关联数据源 --><property name="dataSource" ref="dataSource"/><!-- 配置Hibernate的属性信息 --><property name="jpaVendorAdapter"><bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"><property name="database" value="MYSQL"/><property name="generateDdl" value="true"/><property name="showSql" value="true"/></bean><!--<props><prop key="show_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props>--></property><!-- 扫描路径 --><property name="packagesToScan"><list><value>com.bobo.pojo</value></list></property></bean><!-- 配置事务管理--><bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager"><property name="entityManagerFactory" ref="sessionFactory" /></bean><!-- 配置开启事务注解 --><tx:annotation-driven transaction-manager="transactionManager" /><!-- 配置扫描路径 --><context:component-scan base-package="com.bobo" />
</beans>4. 创建POJO
package com.bobo.pojo;import javax.persistence.*;
import java.io.Serializable;@Entity
@Table(name="t_user")
public class Users implements Serializable {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name="user_id")private Integer userId;@Column(name="user_name")private String userName;@Column(name="real_name")private String realName;public Integer getUserId() {return userId;}public void setUserId(Integer userId) {this.userId = userId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getRealName() {return realName;}public void setRealName(String realName) {this.realName = realName;}@Overridepublic String toString() {return "Users{" +"userId=" + userId +", userName='" + userName + '\'' +", realName='" + realName + '\'' +'}';}
}
5. 创建持久层
package com.bobo.dao;import com.bobo.pojo.Users;import java.util.List;public interface IUserDao {void insertUsers(Users users);void updateUsers(Users users);void deleteUsers(Users users);Users selectUsersById(Integer userId);List<Users> selectUsersByName(String userName);List<Users> selectUsersByNameUseSQL(String userName);List<Users> selectUsersByNameUseCriteria(String userName);
}
实现类
package com.bobo.dao.impl;import com.bobo.dao.IUserDao;
import com.bobo.pojo.Users;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.List;@Repository
public class UserDaoImpl implements IUserDao {@PersistenceContext(name = "entityManagerFactory")private EntityManager manager;@Overridepublic void insertUsers(Users users) {manager.persist(users);}@Overridepublic void updateUsers(Users users) {manager.merge(users);}@Overridepublic void deleteUsers(Users users) {users = this.selectUsersById(users.getUserId());manager.remove(users);}@Overridepublic Users selectUsersById(Integer userId) {return manager.find(Users.class,userId);}@Overridepublic List<Users> selectUsersByName(String userName) {return manager.createQuery(" from Users where userName = :abc").setParameter("abc",userName).getResultList();}@Overridepublic List<Users> selectUsersByNameUseSQL(String userName) {return manager.createNativeQuery("select * from t_user where user_name = ?",Users.class).setParameter(1,userName).getResultList();}@Overridepublic List<Users> selectUsersByNameUseCriteria(String userName) {CriteriaBuilder builder = manager.getCriteriaBuilder();CriteriaQuery<Users> query = builder.createQuery(Users.class);Root<Users> root = query.from(Users.class);Predicate cate = builder.equal(root.get("userName"), userName);query.where(cate);TypedQuery<Users> typedQuery = manager.createQuery(query);return typedQuery.getResultList();}
}
6. 单元测试
package com.bobo.test;import com.bobo.dao.IUserDao;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test1 {@Autowiredprivate IUserDao dao;@Test@Transactional@Rollback(false)public void testInsertUser(){Users user = new Users();user.setUserName("Mic");user.setRealName("李逵");dao.insertUsers(user);}@Test@Transactionalpublic void testQuery1(){Users users = this.dao.selectUsersById(22);System.out.println(users);}@Test@Transactionalpublic void testQuery2(){List<Users> list = this.dao.selectUsersByNameUseSQL("Tom");for (Users users : list) {System.out.println(users);}}}
三、SpringDataJPA介绍
1. 入门案例
1.1 创建项目
创建一个普通的Maven项目。
1.2 添加相关的依赖
<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.2</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.8</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.11</version></dependency><dependency><groupId>org.hibernate</groupId><artifactId>hibernate-entitymanager</artifactId><version>5.0.7.Final</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.1.6.RELEASE</version></dependency><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-jpa</artifactId><version>1.9.0.RELEASE</version></dependency></dependencies>1.3 添加配置文件
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/logistics?characterEncoding=utf-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456
Spring的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:jpa="http://www.springframework.org/schema/data/jpa"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsdhttp://www.springframework.org/schema/data/jpahttp://www.springframework.org/schema/data/jpa/spring-jpa.xsd
"><!-- 引入db.properties文件 --><context:property-placeholder location="classpath:db.properties" /><!-- 创建druid 的数据源 --><bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource"><property name="url" value="${jdbc.url}" /><property name="driverClassName" value="${jdbc.driver}" /><property name="username" value="${jdbc.username}" /><property name="password" value="${jdbc.password}" /></bean><!-- 配置Hibernate的SessionFactory对象 id必须得是 ： entityManagerFactory --><bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"id="entityManagerFactory"><!-- 关联数据源 --><property name="dataSource" ref="dataSource"/><!-- 配置Hibernate的属性信息 --><property name="jpaVendorAdapter"><bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"><property name="database" value="MYSQL"/><property name="generateDdl" value="true"/><property name="showSql" value="true"/></bean><!--<props><prop key="show_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props>--></property><!-- 扫描路径 --><property name="packagesToScan"><list><value>com.bobo.pojo</value></list></property></bean><!-- 配置事务管理--><bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager"><property name="entityManagerFactory" ref="entityManagerFactory" /></bean><!-- 配置开启事务注解 --><tx:annotation-driven transaction-manager="transactionManager" /><!-- 配置扫描路径 --><context:component-scan base-package="com.bobo" /><!-- Spring Data Jpa 配置--><!-- 配置Dao的扫描 --><jpa:repositories base-package="com.bobo.dao" />
</beans>1.4 创建POJO对象
package com.bobo.pojo;import javax.persistence.*;
import java.io.Serializable;@Entity
@Table(name="t_user")
public class Users implements Serializable {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name="user_id")private Integer userId;@Column(name="user_name")private String userName;@Column(name="real_name")private String realName;public Integer getUserId() {return userId;}public void setUserId(Integer userId) {this.userId = userId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getRealName() {return realName;}public void setRealName(String realName) {this.realName = realName;}@Overridepublic String toString() {return "Users{" +"userId=" + userId +", userName='" + userName + '\'' +", realName='" + realName + '\'' +'}';}
}
1.5 创建持久层
package com.bobo.dao;import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;public interface UserDao extends JpaRepository<Users,Integer> {}
1.6 单元测试
package com.bobo.test;import com.bobo.dao.UserDao;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test1 {@Autowiredprivate UserDao dao;@Test@Transactional@Rollback(false)public void test1(){Users user = new Users();user.setUserName("admin-jpa");user.setRealName("测试");dao.save(user);}
}
2. Repository接口
public interface Repository<T, ID extends Serializable> {
} Repository 接口是 Spring Data JPA 中为我我们提供的所有接口中的顶层接口,而且是个标志接口，Repository 提供了两种查询方式的支持。
1）基于方法名称命名规则查询
2）基于@Query 注解查询
2.1 基于方法名称命名规则查询
package com.bobo.dao;import com.bobo.pojo.Users;
import org.springframework.data.repository.Repository;import javax.persistence.criteria.CriteriaBuilder;
import java.util.List;/*** Repository接口的使用*/
public interface UserDaoRepository extends Repository<Users, Integer> {List<Users> findByUserNameIs(String string);List<Users> findByUserNameLike(String username);List<Users> findByUserNameAndRealNameIs(String name,String realName);
}
测试代码
package com.bobo.test;import com.bobo.dao.UserDaoRepository;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test2 {@Autowiredprivate UserDaoRepository dao;@Test@Transactional@Rollback(false)public void query1(){List<Users> list = this.dao.findByUserNameIs("Tom");for (Users users : list) {System.out.println(users);}}@Test@Transactional@Rollback(false)public void query2(){List<Users> list = this.dao.findByUserNameLike("Tom");for (Users users : list) {System.out.println(users);}}@Test@Transactional@Rollback(false)public void query3(){List<Users> list = this.dao.findByUserNameAndRealNameIs("Tom","张三丰");for (Users users : list) {System.out.println(users);}}
}
2.2 基于@Query 注解查询
通过上面的命令的方式使用的情况，如果查询条件比较复杂的情况下，那么方法的名称会很长，不是很方便而且容易出错，这时我们可以通过@Query注解来实现。
2.2.1 JPQL语句
JPQL：是通过Hibernate的HQL语句演变而来的，他和HQL语句很相似。
package com.bobo.dao;import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;import java.util.List;/*** Repository接口的使用* @Query* JPQL语句* SQL语句* 更新操作*/
public interface UserDaoRepository2 extends Repository<Users, Integer> {@Query(value = " from Users where userName =?")List<Users> queryUsersByNameUseJPQL(String name);@Query(value = " from Users where userName like ?")List<Users> queryUserLikeNameUseJPQL(String name);@Query(value = " from Users where userName= ? and realName = ?")List<Users> queryUserByNameAndRealName(String userName,String realName);}
单元测试
package com.bobo.test;import com.bobo.dao.UserDaoRepository;
import com.bobo.dao.UserDaoRepository2;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test3 {@Autowiredprivate UserDaoRepository2 dao;@Test@Transactional@Rollback(false)public void query1(){List<Users> list = this.dao.queryUsersByNameUseJPQL("Tom");for (Users users : list) {System.out.println(users);}}@Test@Transactional@Rollback(false)public void query2(){List<Users> list = this.dao.queryUserLikeNameUseJPQL("Tom");for (Users users : list) {System.out.println(users);}}@Test@Transactional@Rollback(false)public void query3(){List<Users> list = this.dao.queryUserByNameAndRealName("Tom","张三丰");for (Users users : list) {System.out.println(users);}}
}
2.2.2 SQL语句
声明接口
package com.bobo.dao;import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;import java.util.List;/*** Repository接口的使用* @Query* JPQL语句* SQL语句* 更新操作*/
public interface UserDaoRepository3 extends Repository<Users, Integer> {// 在使用@Query注解 查询SQL语句的时候 nativeQuery默认是false，我们需要设置为true@Query(value = "select * from t_user where user_name=?",nativeQuery = true)List<Users> queryUsersByNameUseSQL(String name);@Query(value = "select * from t_user where user_name like ?" ,nativeQuery = true)List<Users> queryUserLikeNameUseSQL(String name);@Query(value = "select * from t_user where user_name = ? and real_name = ?" , nativeQuery = true)List<Users> queryUserByNameAndRealName(String userName,String realName);}
单元测试
package com.bobo.test;import com.bobo.dao.UserDaoRepository2;
import com.bobo.dao.UserDaoRepository3;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test4 {@Autowiredprivate UserDaoRepository3 dao;@Test@Transactional@Rollback(false)public void query1(){List<Users> list = this.dao.queryUsersByNameUseSQL("Tom");for (Users users : list) {System.out.println(users);}}@Test@Transactional@Rollback(false)public void query2(){List<Users> list = this.dao.queryUserLikeNameUseSQL("Tom");for (Users users : list) {System.out.println(users);}}@Test@Transactional@Rollback(false)public void query3(){List<Users> list = this.dao.queryUserByNameAndRealName("Tom","张三丰");for (Users users : list) {System.out.println(users);}}
}
2.2.3 完成更新数据
@Query注解可以完成数据更新操作，但是不能实现数据的添加和删除操作。
@Query(value = "update Users set userName = ? where userId=?")
@Modifying// 被@Modifying修饰的方法是一个更新操作
void updateUserNameById(String userName,Integer userId); 测试
@Test
@Transactional
@Rollback(false)
public void updateTest(){this.dao.updateUserNameById("Tommm",25);
}
3. CrudRepository接口
CrudRepository接口继承自Repository接口，所以Repository接口具有的功能CrudRepository接口都具有，而且又扩展了CRUD相关的功能。
@NoRepositoryBean
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {<S extends T> S save(S var1);<S extends T> Iterable<S> save(Iterable<S> var1);T findOne(ID var1);boolean exists(ID var1);Iterable<T> findAll();Iterable<T> findAll(Iterable<ID> var1);long count();void delete(ID var1);void delete(T var1);void delete(Iterable<? extends T> var1);void deleteAll();
} 应用声明接口
/**
* CrudRepository接口的使用
*/
public interface UserDaoCrudRepository extends CrudRepository<Users,Integer> {
} 单元测试
package com.bobo.test;import com.bobo.dao.UserDaoCrudRepository;
import com.bobo.dao.UserDaoRepository3;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.experimental.theories.suppliers.TestedOn;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.support.CustomSQLErrorCodesTranslation;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test5 {@Autowiredprivate UserDaoCrudRepository dao;/*** 添加数据*/@Testpublic void test1(){Users user = new Users();user.setRealName("成龙");user.setUserName("chengnong");dao.save(user);}/*** 批量添加数据*/@Testpublic void test2(){List<Users> list = new ArrayList<>();for (int i = 0; i < 10; i++) {Users user = new Users();user.setRealName("成龙"+i);user.setUserName("chengnong"+i);list.add(user);}dao.save(list);}/*** 查询单条数据*/@Testpublic void test3(){Users user = dao.findOne(25);System.out.println(user);}/*** 查询所有的数据*/@Testpublic void test4(){Iterable<Users> list = dao.findAll();Iterator<Users> iterator = list.iterator();while(iterator.hasNext()){Users user = iterator.next();System.out.println(user);}}/*** 删除数据*/@Testpublic void delete1(){dao.delete(32);}/*** 更新数据*/@Testpublic void update1(){// 根据save方法来实现 如果Users对象的userId属性不为空则updateUsers user = dao.findOne(34);user.setUserName("hahahaha");dao.save(user);}/*** 更新数据 方式二*/@Test@Transactional@Rollback(false)public void update2(){Users user = dao.findOne(34);user.setUserName("aaaa"); // User 是一个持久化的状态}
}
4.PagingAndSortingRepository接口
PagingAndSortingRepository继承自CrudRepository接口，那么显然PagingAndSortingRepository就具备了CrudRepository接口的相关的功能，同时也扩展了分页和排序的功能。
@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {// 排序的支持Iterable<T> findAll(Sort var1);// 分页的支持Page<T> findAll(Pageable var1);
} 创建接口文件
package com.bobo.dao;import com.bobo.pojo.Users;
import org.springframework.data.repository.PagingAndSortingRepository;/*** PagingAndSortingRepository接口的使用* 新增的功能是* 分页* 排序* 注意本接口不支持条件查询*/
public interface UserDaoPageAndSortRepository extends PagingAndSortingRepository<Users,Integer> {
}
分页测试
package com.bobo.test;import com.bobo.dao.UserDaoCrudRepository;
import com.bobo.dao.UserDaoPageAndSortRepository;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test6 {@Autowiredprivate UserDaoPageAndSortRepository dao;/*** 分页查询*/@Testpublic void test1(){int page = 1; // page:当前分页的索引 从0开始int size = 5; // size:每页显示的条数PageRequest pageable = new PageRequest(page,size);Page<Users> pages = dao.findAll(pageable);System.out.println("总的条数:" + pages.getTotalElements());System.out.println("总的页数:" + pages.getTotalPages());List<Users> list = pages.getContent();for (Users user : list) {System.out.println(user);}}
}
排序功能
/*** 排序*/@Testpublic void test2(){// Sort.Direction.DESC 降序 ASC 升序Sort sort = new Sort(Sort.Direction.DESC,"userId");List<Users> list = (List<Users>) this.dao.findAll(sort);for (Users users : list) {System.out.println(users);}}
多条件排序
/*** 多条件排序*/@Testpublic void test3(){Sort.Order order1 = new Sort.Order(Sort.Direction.DESC,"realName");Sort.Order order2 = new Sort.Order(Sort.Direction.ASC,"userId");Sort sort = new Sort(order1,order2);List<Users> list = (List<Users>) this.dao.findAll(sort);for (Users users : list) {System.out.println(users);}}
5. JpaRepository接口
JpaRepository接口是我们开发时使用最多接口，其特点是可以帮助我们将其他接口的方法的返回值做适配处理，可以使我们在开发的时候更方便的使用这些方法。
@NoRepositoryBean
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {List<T> findAll();List<T> findAll(Sort var1);List<T> findAll(Iterable<ID> var1);<S extends T> List<S> save(Iterable<S> var1);void flush();<S extends T> S saveAndFlush(S var1);void deleteInBatch(Iterable<T> var1);void deleteAllInBatch();T getOne(ID var1);
}6. JpaSpecificationExecutor
提供的有多条件查询，并支持分页和排序功能，此接口不能单独使用，需要和其他的接口一块使用。
/**
* JpaSpecificationExecutor的使用
* JpaSpecificationExecutor 是不能够单独使用的。需要配置JPA中的其他的接口一块来使用
*/
public interface UserDaoSpecfication extends JpaRepository<Users,Integer>, JpaSpecificationExecutor {
}6.1 单条件查询
package com.bobo.test;import com.bobo.dao.UserDaoSpecfication;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test7 {@Autowiredprivate UserDaoSpecfication dao;@Testpublic void test1(){Specification<Users> speci = new Specification<Users>() {/*** 定义查询条件* @param root 根对象 封装查询条件的对象* @param criteriaQuery 基本的查询* @param criteriaBuilder 创建查询条件* @return*/@Overridepublic Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");return pre;}};List<Users> list = dao.findAll(speci);for (Users users : list) {System.out.println(users);}}
}
6.2 多条件
/*** 多条件查询*/@Testpublic void test2(){Specification<Users> spec = new Specification<Users>() {/*** 指定查询的条件* @param root* @param criteriaQuery* @param criteriaBuilder* @return*/@Overridepublic Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {List<Predicate> list = new ArrayList<>();list.add(criteriaBuilder.equal(root.get("userName"),"Tommm"));list.add(criteriaBuilder.equal(root.get("realName"),"张三丰"));Predicate[] arr = new Predicate[list.size()];return criteriaBuilder.and(list.toArray(arr));}};List<Users> list = dao.findAll(spec);for (Users users : list) {System.out.println(users);}}
6.3 分页
/*** 单条件+分页*/@Testpublic void test3(){Specification<Users> speci = new Specification<Users>() {/*** 定义查询条件* @param root 根对象 封装查询条件的对象* @param criteriaQuery 基本的查询* @param criteriaBuilder 创建查询条件* @return*/@Overridepublic Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");return pre;}};Pageable pagealbe = (Pageable) new PageRequest(0,3);Page page = dao.findAll(speci, pagealbe);System.out.println(page.getTotalElements());System.out.println(page.getTotalPages());List content = page.getContent();System.out.println(content);}
6.4 排序
/*** 单条件+排序*/@Testpublic void test4(){Specification<Users> speci = new Specification<Users>() {/*** 定义查询条件* @param root 根对象 封装查询条件的对象* @param criteriaQuery 基本的查询* @param criteriaBuilder 创建查询条件* @return*/@Overridepublic Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");return pre;}};Sort sort = new Sort(Sort.Direction.DESC,"userId");List<Users> list = dao.findAll(speci, sort);System.out.println(list);}
6.5 分页和排序
/*** 单条件+分页 + 排序*/@Testpublic void test5(){Specification<Users> speci = new Specification<Users>() {/*** 定义查询条件* @param root 根对象 封装查询条件的对象* @param criteriaQuery 基本的查询* @param criteriaBuilder 创建查询条件* @return*/@Overridepublic Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");return pre;}};Sort sort = new Sort(Sort.Direction.DESC,"userId");// 封装分页对象的时候我们可以直接指定 排序的规则Pageable pagealbe = (Pageable) new PageRequest(0,3,sort);Page page = dao.findAll(speci, pagealbe);System.out.println(page.getTotalElements());System.out.println(page.getTotalPages());List content = page.getContent();System.out.println(content);}
四、SpringBoot整合SpringDataJPA
1. 添加依赖
2. 添加配置文件
# jdbc 的相关信息
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/logistics?
characterEncoding=utf-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456# 配置连接池信息
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource# 配置jpa的相关参数
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true3. 创建POJO
package com.bobo.pojo;import javax.persistence.*;
import java.io.Serializable;@Table(name = "t_user")
@Entity
public class Users implements Serializable {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)@Column(name="user_id")private Integer userId;@Column(name="user_name")private String usreName;@Column(name="real_name")private String realName;public Integer getUserId() {return userId;}public void setUserId(Integer userId) {this.userId = userId;}public String getUsreName() {return usreName;}public void setUsreName(String usreName) {this.usreName = usreName;}public String getRealName() {return realName;}public void setRealName(String realName) {this.realName = realName;}
}
4. 创建接口
package com.bobo.dao;import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;public interface UsersRepository extends JpaRepository<Users,Integer> {
}
5. 测试
package com.bobo;import com.bobo.dao.UsersRepository;
import com.bobo.pojo.Users;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;@SpringBootTest
class SpringdatajpaSpringbootApplicationTests {@Autowiredprivate UsersRepository dao;@Testvoid contextLoads() {Users users = new Users();users.setUsreName("test1");users.setRealName("测试数据");dao.save(users);}}
相关文章：
Java经典框架之SpringDataJPA
SpringDataJPA Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。 课程内容的介绍 1. Spring整合Hibernate 2…...
向爬虫而生---Redis 基石篇3 ＜拓展List＞
前言: 继上一篇向爬虫而生---Redis 基石篇2 ＜拓展Hash＞-CSDN博客.往下继续---挖一挖list 正文: 在Redis中，列表（List）是一个常用的数据结构，尤其在爬虫应用中。例如，可以用列表实现…...
CSS渲染性能优化
✨ 专栏介绍 HTML/CSS专栏合集是一个涵盖HTML和CSS两个方面的栏目。HTML是一种标记语言，用于创建网页的结构和内容，而CSS是一种样式表语言，用于控制网页的外观和布局。 在HTML/CSS专栏合集中，我们将深入探讨HTML和CSS的基础知识…...
【C++入门】类和对象（完）
前言 在谈论C时，常常会涉及到一些高级特性和概念，比如初始化列表、static成员、友元、内部类、匿名对象等。这些概念在C编程中起着非常重要的作用，对于想要深入了解C语言的开发者来说，掌握这些知识是至关重要的。本文，…...
webshell检测方式深度剖析 --- Pixy系列二（数据流分析）
开篇 书接上文，这次我们来聊聊数据流分析，数据流分析的内容非常广泛，我们力求深入浅出通俗易懂，在简短的篇幅内将这一概念描述清楚。 简单来说，数据流分析是一种用来获取相关数据沿着程序执行路径流动的信息分析技术…...
[DAU-FI Net开源 | Dual Attention UNet+特征融合+Sobel和Canny等算子解决语义分割痛点]
文章目录 概要I Introduction小结 概要 提出的架构，双注意力U-Net与特征融合（DAU-FI Net），解决了语义分割中的挑战，特别是在多类不平衡数据集上，这些数据集具有有限的样本。DAU-FI Net 整合了多尺度空间-通…...
使用Triton部署ONNX模型
介绍 适用于各种 AI 工作负载的推理：借助 NVIDIA Triton™，在任何处理器（GPU、CPU 或其他）上，对使用基于任何框架的，经过训练的机器学习模型或深度学习模型，进行推理部署。Triton 是 NVIDIA AI…...
Python访问ElasticSearch
ElasticSearch是广受欢迎的NoSQL数据库，其分布式架构提供了极佳的数据空间的水平扩展能力，同时保障了数据的可靠性；反向索引技术使得数据检索和查询速度非常快。更多功能参见官网介绍 https://www.elastic.co/cn/elasticsearch/ 下面简单罗列…...
Flutter 混合开发 - 动态下发 libflutter.so libapp.so
背景 最近在做包体积优化，在完成代码混淆、压缩，裁剪ndk支持架构，以及资源压缩（如图片转webp、mp3压缩等）后发现安装包的中占比较大的仍是 so 动态库依赖。 具体查看发现 libflutter.so 和 libapp.so 的体积是最大的&…...
Peter算法小课堂—动态规划
Peter推荐算法书：《算法导论》 图示： 目录 钢条切割 打字怪人 钢条切割 算法导论（第四版）第十四章第一节：钢条切割 题目描述： 给定一根长度为 n 英寸的钢条和一个价格表 ，其中 i1,2,…,n …...
2022–2023学年2021级计算机科学与技术专业数据库原理 （A）卷
一、单项选择题（每小题1.5分，共30分） 1、构成E—R模型的三个基本要素是（ B ）。 A．实体、属性值、关系 B．实体、属性、联系 C．实体、实体集、联系 D．实体、实体…...
Clojure 实战(4)：编写 Hadoop MapReduce 脚本
Hadoop简介 众所周知，我们已经进入了大数据时代，每天都有PB级的数据需要处理、分析，从中提取出有用的信息。Hadoop就是这一时代背景下的产物。它是Apache基金会下的开源项目，受Google两篇论文的启发，采用分布式的文件…...
Django 分页（表单）
目录 一、手动分页二、分页器分页 一、手动分页 1、概念 页码：很容易理解，就是一本书的页码每页数量：就是一本书中某一页中的内容（数据量，比如第二页有15行内容），这 15 就是该页的数据量 每一…...
socket实现视频通话-WebRTC
最近喜欢研究视频流，所以思考了双向通信socket，接下来我们就一起来看看本地如何实现双向视频通讯的功能吧~ 客户端获取视频流 首先思考如何获取视频流呢？ 其实跟录音的功能差不多，都是查询电脑上是否有媒体设备，如果…...
simulink代码生成（九）—— 串口显示数据（纸飞机联合调试）
纸飞机里面的协议是固定的，必须按照协议配置； （1）使用EasyHEX协议，测试int16数据类型 测试串口发出的数据是否符合？ 串口接收数据为： 打开纸飞机绘图侧： （1）…...
Mysql数据库（中）——增删改查的学习（全面，详细）
上一篇主要对查询操作进行了详细的总结，本篇主要对增删改操作以及一些常用的函数进行总结，包括流程控制等；以下的代码可以直接复制到数据库可视化软件中，便于理解和练习； 常用的操作： #函数： S…...
test dbtest-03-对比 Liquibase、flyway、dbDeploy、dbsetup
详细对比 Liquibase、flyway、dbDeploy、dbsetup，给出对比表格 下面是一个简要的对比表格，涵盖了 Liquibase、Flyway、dbDeploy 和 DbSetup 这四个数据库变更管理工具的一些主要特点。 特点/工具LiquibaseFlywaydbDeployDbSetup开发语言Java࿰…...
力导向图与矩阵排序
Graph-layout force directed（力导向图布局）是一种用于可视化网络图的布局算法。它基于物理模型，模拟了图中节点之间的相互排斥和连接弹性，以生成具有良好可读性和美观性的图形布局。 在力导向图布局中，每个节点被视为…...
word 常用功能记录
word手册 多行文字对齐标题调整文字间距打钩方框插入三线表插入参考文献自动生成目录 多行文字对齐 标题调整文字间距 打钩方框 插入三线表 插入一个最基本的表格把整个表格设置为无框线设置上框线【实线1.5磅】设置下框线【实线1.5磅】选中第一行，设置下框线【实线…...
C#线程基础（线程启动和停止）
目录 一、关于线程 二、示例 三、生成效果 一、关于线程 在使用多线程前要先引用命名空间System.Threading，引用命名空间后就可以在需要的地方方便地创建并使用线程。 创建线程对象的构造方法中使用了ThreadStart()委托，当线程开始执行时，…...
python爬虫：Newspaper3k 的详细使用（好用的新闻网站文章抓取和解析的Python库）
更多内容请见： 爬虫和逆向教程-专栏介绍和目录 文章目录 一、Newspaper3k 概述1.1 Newspaper3k 介绍1.2 主要功能1.3 典型应用场景1.4 安装二、基本用法2.2 提取单篇文章的内容2.2 处理多篇文档三、高级选项3.1 自定义配置3.2 分析文章情感四、实战案例4.1 构建新闻摘要聚合器…...
Cloudflare 从 Nginx 到 Pingora：性能、效率与安全的全面升级
在互联网的快速发展中，高性能、高效率和高安全性的网络服务成为了各大互联网基础设施提供商的核心追求。Cloudflare 作为全球领先的互联网安全和基础设施公司，近期做出了一个重大技术决策：弃用长期使用的 Nginx，转而采用其内部开发…...
Device Mapper 机制
Device Mapper 机制详解 Device Mapper（简称 DM）是 Linux 内核中的一套通用块设备映射框架，为 LVM、加密磁盘、RAID 等提供底层支持。本文将详细介绍 Device Mapper 的原理、实现、内核配置、常用工具、操作测试流程，并配以详细的…...
微软PowerBI考试 PL300-在 Power BI 中清理、转换和加载数据
微软PowerBI考试 PL300-在 Power BI 中清理、转换和加载数据 Power Query 具有大量专门帮助您清理和准备数据以供分析的功能。 您将了解如何简化复杂模型、更改数据类型、重命名对象和透视数据。 您还将了解如何分析列，以便知晓哪些列包含有价值的数据，…...
Python基于历史模拟方法实现投资组合风险管理的VaR与ES模型项目实战
说明：这是一个机器学习实战项目（附带数据代码文档），如需数据代码文档可以直接到文章最后关注获取。 1.项目背景 在金融市场日益复杂和波动加剧的背景下，风险管理成为金融机构和个人投资者关注的核心议题之一。VaR&…...
Python Ovito统计金刚石结构数量
大家好，我是小马老师。 本文介绍python ovito方法统计金刚石结构的方法。 Ovito Identify diamond structure命令可以识别和统计金刚石结构，但是无法直接输出结构的变化情况。 本文使用python调用ovito包的方法，可以持续统计各步的金刚石结构，具体代码如下： from ovito…...
比较数据迁移后MySQL数据库和OceanBase数据仓库中的表
设计一个MySQL数据库和OceanBase数据仓库的表数据比较的详细程序流程，两张表是相同的结构，都有整型主键id字段，需要每次从数据库分批取得2000条数据，用于比较，比较操作的同时可以再取2000条数据，等上一次比较完成之后，开始比较，直到比较完所有的数据。比较操作需要比较…...
LangFlow技术架构分析
🔧 LangFlow 的可视化技术栈 前端节点编辑器 底层框架：基于 （一个现代化的 React 节点绘图库） 功能： 拖拽式构建 LangGraph 状态机 实时连线定义节点依赖关系 可视化调试循环和分支逻辑 与 LangGraph 的深…...
LOOI机器人的技术实现解析：从手势识别到边缘检测
LOOI机器人作为一款创新的AI硬件产品，通过将智能手机转变为具有情感交互能力的桌面机器人，展示了前沿AI技术与传统硬件设计的完美结合。作为AI与玩具领域的专家，我将全面解析LOOI的技术实现架构，特别是其手势识别、物体识别和环境…...
如何通过git命令查看项目连接的仓库地址？
要通过 Git 命令查看项目连接的仓库地址，您可以使用以下几种方法： 1. 查看所有远程仓库地址 使用 git remote -v 命令，它会显示项目中配置的所有远程仓库及其对应的 URL： git remote -v输出示例： origin https://…...