AI 助理
备案控制台
开发者社区 数据库 文章 正文

对ORM的支持 之 8.4 集成JPA ——跟我学spring3

2015-05-28 860
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 8.4  集成JPA        JPA全称为Java持久性API（Java Persistence API），JPA是Java EE 5标准之一，是一个ORM规范，由厂商来实现该规范，目前有Hibernate、OpenJPA、TopLink、EclipseJPA等实现。

8.4  集成JPA

       JPA全称为Java持久性API（Java Persistence API），JPA是Java EE 5标准之一，是一个ORM规范，由厂商来实现该规范，目前有Hibernate、OpenJPA、TopLink、EclipseJPA等实现。

 

8.4.1  如何集成

       Spring目前提供集成Hibernate、OpenJPA、TopLink、EclipseJPA四个JPA标准实现。

       Spring通过使用如下Bean进行集成JPA（EntityManagerFactory）：

  • LocalEntityManagerFactoryBean：适用于那些仅使用JPA进行数据访问的项目，该FactoryBean将根据JPA PersistenceProvider自动检测配置文件进行工作，一般从“META-INF/persistence.xml”读取配置信息，这种方式最简单，但不能设置Spring中定义的DataSource，且不支持Spring管理的全局事务，而且JPA 实现商可能在JVM启动时依赖于VM agent从而允许它们进行持久化类字节码转换（不同的实现厂商要求不同，需要时阅读其文档），不建议使用这种方式；

         persistenceUnitName：指定持久化单元的名称；

         使用方式：

 

java代码：
查看 复制到剪贴板 打印
  1. <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">  
  2.     <property name="persistenceUnitName" value="persistenceUnit"/>  
  3. </bean>  
  • 从JNDI中获取：用于从Java EE服务器获取指定的EntityManagerFactory，这种方式在进行Spring事务管理时一般要使用JTA事务管理；

      使用方式：

 

java代码：
查看 复制到剪贴板 打印
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns:jee="http://www.springframework.org/schema/jee"  
  4.     xsi:schemaLocation="  
  5.        http://www.springframework.org/schema/beans  
  6.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.        http://www.springframework.org/schema/jee  
  8.        http://www.springframework.org/schema/jee/spring-jee-3.0.xsd">  
  9.   <jee:jndi-lookup id="entityManagerFactory"  jndi-name="persistence/persistenceUnit"/>  
  10. </beans>  

 

此处需要使用“jee”命名标签，且使用<jee:jndi-lookup>标签进行JNDI查找，“jndi-name”属性用于指定JNDI名字。

  • LocalContainerEntityManagerFactoryBean：适用于所有环境的FactoryBean，能全面控制EntityManagerFactory配置,如指定Spring定义的DataSource等等。

         persistenceUnitManager：用于获取JPA持久化单元，默认实现DefaultPersistenceUnitManager用于解决多配置文件情况

 

         dataSource：用于指定Spring定义的数据源；

 

         persistenceXmlLocation：用于指定JPA配置文件，对于对配置文件情况请选择设置persistenceUnitManager属性来解决；

 

         persistenceUnitName：用于指定持久化单元名字；

 

         persistenceProvider：用于指定持久化实现厂商类；如Hibernate为org.hibernate.ejb.HibernatePersistence类；

 

         jpaVendorAdapter：用于设置实现厂商JPA实现的特定属性，如设置Hibernate的是否自动生成DDL的属性generateDdl；这些属性是厂商特定的，因此最好在这里设置；目前Spring提供HibernateJpaVendorAdapter、OpenJpaVendorAdapter、EclipseLinkJpaVendorAdapter、TopLinkJpaVendorAdapter、OpenJpaVendorAdapter四个实现。其中最重要的属性是“database”，用来指定使用的数据库类型，从而能根据数据库类型来决定比如如何将数据库特定异常转换为Spring的一致性异常，目前支持如下数据库（DB2、DERBY、H2、HSQL、INFORMIX、MYSQL、ORACLE、POSTGRESQL、SQL_SERVER、SYBASE）。

 

         jpaDialect：用于指定一些高级特性，如事务管理，获取具有事务功能的连接对象等，目前Spring提供HibernateJpaDialect、OpenJpaDialect 、EclipseLinkJpaDialect、TopLinkJpaDialect、和DefaultJpaDialect实现，注意DefaultJpaDialect不提供任何功能，因此在使用特定实现厂商JPA实现时需要指定JpaDialect实现，如使用Hibernate就使用HibernateJpaDialect。当指定jpaVendorAdapter属性时可以不指定jpaDialect，会自动设置相应的JpaDialect实现；

 

         jpaProperties和jpaPropertyMap：指定JPA属性；如Hibernate中指定是否显示SQL的“hibernate.show_sql”属性，对于jpaProperties设置的属性自动会放进jpaPropertyMap中；

         loadTimeWeaver：用于指定LoadTimeWeaver实现，从而允许JPA 加载时修改相应的类文件。具体使用得参考相应的JPA规范实现厂商文档，如Hibernate就不需要指定loadTimeWeaver。

接下来学习一下Spring如何集成JPA吧：

1、准备jar包，从下载的hibernate-distribution-3.6.0.Final包中获取如下Hibernate需要的jar包从而支持JPA：

 

lib\jpa\hibernate-jpa-2.0-api-1.0.0.Final.jar //用于支持JPA

             

2、对象模型定义，此处使用UserModel2：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter8;  
  2. //省略import  
  3. @Entity  
  4. @Table(name = "test")  
  5. public class UserModel2 {  
  6.     @Id @GeneratedValue(strategy = GenerationType.AUTO)  
  7.     private int id;  
  8.     @Column(name = "name")  
  9.     private String myName;  
  10.     //省略getter和setter  
  11. }  

 

注意此处使用的所有注解都是位于javax.persistence包下，如使用@org.hibernate.annotations.Entity 而非@javax.persistence. Entity将导致JPA不能正常工作。

 

1、 JPA配置定义（chapter8/persistence.xml），定义对象和数据库之间的映射：

 

java代码：
查看 复制到剪贴板 打印
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <persistence version="1.0"  
  3.     xmlns="http://java.sun.com/xml/ns/persistence"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence                      http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">  
  6.     <persistence-unit name="persistenceUnit" transaction-type="RESOURCE_LOCAL"/>  
  7. </persistence>  
  8.    

      在JPA配置文件中，我们指定要持久化单元名字，和事务类型，其他都将在Spring中配置。

 

2、 数据源定义，此处使用第7章的配置文件，即“chapter7/ applicationContext-resources.xml”文件。

 

3、 EntityManagerFactory配置定义（chapter8/applicationContext-jpa.xml）：

 

java代码：
查看 复制到剪贴板 打印
  1. <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
  2.   <property name="dataSource" ref="dataSource"/>  
  3.   <property name="persistenceXmlLocation" value="chapter8/persistence.xml"/>  
  4.   <property name="persistenceUnitName" value="persistenceUnit"/>  
  5.   <property name="persistenceProvider" ref="persistenceProvider"/>  
  6.   <property name="jpaVendorAdapter" ref="jpaVendorAdapter"/>  
  7.   <property name="jpaDialect" ref="jpaDialect"/>  
  8.   <property name="jpaProperties">  
  9.       <props>  
  10.           <prop key="hibernate.show_sql">true</prop>  
  11.       </props>  
  12.   </property>  
  13. </bean>  
  14. <bean id="persistenceProvider" class="org.hibernate.ejb.HibernatePersistence"/>  

 

 

java代码：
查看 复制到剪贴板 打印
  1. <bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">  
  2.    <property name="generateDdl" value="false" />  
  3.    <property name="database" value="HSQL"/>  
  4. </bean>  
  5. <bean id="jpaDialect" class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>  
  • LocalContainerEntityManagerFactoryBean:指定使用本地容器管理EntityManagerFactory，从而进行细粒度控制；
  • dataSource属性指定使用Spring定义的数据源；
  • persistenceXmlLocation指定JPA配置文件为chapter8/persistence.xml，且该配置文件非常简单，具体配置完全在Spring中进行；
  • persistenceUnitName指定持久化单元名字，即JPA配置文件中指定的;
  • persistenceProvider:指定JPA持久化提供商，此处使用Hibernate实现HibernatePersistence类；
  • jpaVendorAdapter：指定实现厂商专用特性，即generateDdl= false表示不自动生成DDL，database= HSQL表示使用hsqldb数据库；
  • jpaDialect：如果指定jpaVendorAdapter此属性可选，此处为HibernateJpaDialect；
  •  jpaProperties：此处指定“hibernate.show_sql =true”表示在日志系统debug级别下将打印所有生成的SQL。

 

4、 获取EntityManagerFactory：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter8;  
  2. //省略import  
  3. public class JPATest {  
  4.     private static EntityManagerFactory entityManagerFactory;  
  5.     @BeforeClass  
  6.     public static void setUpClass() {  
  7.         String[] configLocations = new String[] {  
  8.                 "classpath:chapter7/applicationContext-resources.xml",  
  9.                 "classpath:chapter8/applicationContext-jpa.xml"};  
  10.         ApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations);  
  11.         entityManagerFactory = ctx.getBean(EntityManagerFactory.class);  
  12.     }  
  13. }  

 

此处我们使用了chapter7/applicationContext-resources.xml定义的“dataSource”数据源，通过ctx.getBean(EntityManagerFactory.class)获取EntityManagerFactory。

 

5、  通过EntityManagerFactory获取EntityManager进行创建和删除表：

 

java代码：
查看 复制到剪贴板 打印
  1. @Before  
  2. public void setUp() throws SQLException {  
  3.    //id自增主键从0开始  
  4.    String createTableSql = "create memory table test" + "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " + "name varchar(100))";  
  5.    executeSql(createTableSql);  
  6. }  
  7. @After  
  8. public void tearDown() throws SQLException {  
  9.     String dropTableSql = "drop table test";  
  10.     executeSql(dropTableSql);  
  11. }  
  12.   
  13. private void executeSql(String sql) throws SQLException {  
  14.   EntityManager em = entityManagerFactory.createEntityManager();  
  15.   beginTransaction(em);  
  16.   em.createNativeQuery(sql).executeUpdate();  
  17.   commitTransaction(em);  
  18.   closeEntityManager(em);  
  19. }  
  20. private void closeEntityManager(EntityManager em) {  
  21.   em.close();  
  22. }  
  23. private void rollbackTransacrion(EntityManager em) throws SQLException {  
  24.   if(em != null) {  
  25.      em.getTransaction().rollback();  
  26.   }           
  27. }  
  28. private void commitTransaction(EntityManager em) throws SQLException {  
  29.    em.getTransaction().commit();  
  30. }  
  31. private void beginTransaction(EntityManager em) throws SQLException {  
  32.    em.getTransaction().begin();  
  33. }  

使用EntityManagerFactory创建EntityManager，然后通过EntityManager对象的createNativeQuery创建本地SQL执行创建和删除表。

 

 

6、 使用EntityManagerFactory获取EntityManager对象进行持久化数据：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testFirst() throws SQLException {  
  3.     UserModel2 model = new UserModel2();  
  4.     model.setMyName("test");  
  5.     EntityManager em = null;  
  6.     try {  
  7.         em = entityManagerFactory.createEntityManager();  
  8.         beginTransaction(em);  
  9.         em.persist(model);  
  10.         commitTransaction(em);  
  11.     } catch (SQLException e) {  
  12.         rollbackTransacrion(em);  
  13.         throw e;  
  14.     } finally {  
  15.       closeEntityManager(em);  
  16.     }  
  17. }  

 

使用EntityManagerFactory获取EntityManager进行操作，看到这还能忍受冗长的代码和事务管理吗？Spring同样提供JpaTemplate模板类来简化这些操作。

大家有没有注意到此处的模型对象能自动映射到数据库，这是因为Hibernate JPA实现默认自动扫描类路径中的@Entity注解类及*.hbm.xml映射文件，可以通过更改Hibernate JPA属性“hibernate.ejb.resource_scanner”，并指定org.hibernate.ejb.packaging.Scanner接口实现来定制新的扫描策略。

 

8.4.2  使用JpaTemplate

JpaTemplate模板类用于简化事务管理及常见操作，类似于JdbcTemplate模板类，对于复杂操作通过提供JpaCallback回调接口来允许更复杂的操作。

       接下来示例一下JpaTemplate的使用：

1、修改Spring配置文件（chapter8/applicationContext-jpa.xml），添加JPA事务管理器：

 

java代码：
查看 复制到剪贴板 打印
  1. <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">  
  2.     <property name="entityManagerFactory" ref="entityManagerFactory"/>  
  3. </bean>  
  4.    
  • txManager：指定事务管理器，JPA使用JpaTransactionManager事务管理器实现，通过entityManagerFactory指定EntityManagerFactory；用于支持Java SE环境的JPA扩展的持久化上下文（EXTENDED Persistence Context）。

2、修改JPATest类，添加类变量ctx，用于后边使用其获取事务管理器使用：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter8;  
  2. public class JPATest {  
  3.     private static EntityManagerFactory entityManagerFactory;  
  4.     private static ApplicationContext ctx;  
  5.     @BeforeClass  
  6.     public static void beforeClass() {  
  7.         String[] configLocations = new String[] {  
  8.                 "classpath:chapter7/applicationContext-resources.xml",  
  9.                 "classpath:chapter8/applicationContext-jpa.xml"};  
  10.         ctx = new ClassPathXmlApplicationContext(configLocations);  
  11.         entityManagerFactory = ctx.getBean(EntityManagerFactory.class);  
  12. }  
  13. }  
  14.    


 

3）JpaTemplate模板类使用：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testJpaTemplate() {  
  3. final JpaTemplate jpaTemplate = new JpaTemplate(entityManagerFactory);  
  4.   final UserModel2 model = new UserModel2();  
  5.   model.setMyName("test1");  
  6.   PlatformTransactionManager txManager = ctx.getBean(PlatformTransactionManager.class);  
  7.   new TransactionTemplate(txManager).execute(  
  8.     new TransactionCallback<Void>() {  
  9.       @Override  
  10.       public Void doInTransaction(TransactionStatus status) {  
  11.         jpaTemplate.persist(model);  
  12.         return null;  
  13.       }  
  14.   });  
  15.   String COUNT_ALL = "select count(*) from UserModel";  
  16.   Number count = (Number) jpaTemplate.find(COUNT_ALL).get(0);  
  17.   Assert.assertEquals(1, count.intValue());  
  18. }  
  19.      
  20.    
  • jpaTemplate：可通过new JpaTemplate(entityManagerFactory)方式创建；
  • txManager：通过ctx.getBean(PlatformTransactionManager.class)获取事务管理器；
  • TransactionTemplate：通过new TransactionTemplate(txManager)创建事务模板对象，并通过execute方法执行TransactionCallback回调中的doInTransaction方法中定义需要执行的操作，从而将由模板类通过txManager事务管理器来进行事务管理，此处是调用jpaTemplate对象的persist方法进行持久化；
  • jpaTemplate.persist()：根据JPA规范，在JPA扩展的持久化上下文，该操作必须运行在事务环境，还有persist()、 merge()、remove()操作也必须运行在事务环境；
  • jpaTemplate.find()：根据JPA规范，该操作无需运行在事务环境，还有find()、getReference()、 refresh()、detach()和查询操作都无需运行在事务环境。

 

此实例与Hibernate和Ibatis有所区别，通过JpaTemplate模板类进行如持久化等操作时必须有运行在事务环境中，否则可能抛出如下异常或警告：

  • “javax.persistence.TransactionRequiredException：Executing an update/delete query”：表示没有事务支持，不能执行更新或删除操作；
  • 警告“delaying identity-insert due to no transaction in progress”：需要在日志系统启动debug模式才能看到，表示在无事务环境中无法进行持久化，而选择了延迟标识插入。

 

以上异常和警告是没有事务造成的，也是最让人困惑的问题，需要大家注意。

 

8.4.3  集成JPA及最佳实践

       类似于JdbcDaoSupport类，Spring对JPA也提供了JpaDaoSupport类来支持一致的数据库访问。JpaDaoSupport也是DaoSupport实现：

       接下来示例一下Spring集成JPA的最佳实践：

 

1、 定义Dao接口，此处使用cn.javass.spring.chapter7.dao. IUserDao：

 

2、 定义Dao接口实现，此处是JPA实现：

 

java代码：
查看 复制到剪贴板 打印
  1. package cn.javass.spring.chapter8.dao.jpa;  
  2. //省略import  
  3. @Transactional(propagation = Propagation.REQUIRED)  
  4. public class UserJpaDaoImpl extends JpaDaoSupport implements IUserDao {  
  5.     private static final String COUNT_ALL_JPAQL = "select count(*) from UserModel";  
  6.     @Override  
  7.     public void save(UserModel model) {  
  8.         getJpaTemplate().persist(model);  
  9.     }  
  10.     @Override  
  11.     public int countAll() {  
  12.         Number count =  
  13.            (Number) getJpaTemplate().find(COUNT_ALL_JPAQL).get(0);  
  14.         return count.intValue();  
  15.     }  
  16. }  

 

 

此处注意首先JPA实现放在dao.jpa包里，其次实现类命名如UserJpaDaoImpl，即×××JpaDaoImpl，当然如果自己有更好的命名规范可以遵循自己的，此处只是提个建议。

另外在类上添加了@Transactional注解表示该类的所有方法将在调用时需要事务支持，propagation传播属性为Propagation.REQUIRED表示事务是必需的，如果执行该类的方法没有开启事务，将开启一个新的事务。

 

3、进行资源配置，使用resources/chapter7/applicationContext-resources.xml：

 

4、dao定义配置，在chapter8/applicationContext-jpa.xml中添加如下配置：

4.1、首先添加tx命名空间用于支持事务：

 

java代码：
查看 复制到剪贴板 打印
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="  
  6.        http://www.springframework.org/schema/beans  
  7.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  8.        http://www.springframework.org/schema/tx  
  9.        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">  

 

4.2、为@Transactional注解事务开启事务支持：

 

 

java代码：
查看 复制到剪贴板 打印
  1. <tx:annotation-driven transaction-manager="txManager"/>  

只为类添加@Transactional 注解是不能支持事务的，需要通过<tx:annotation-driven>标签来开启事务支持，其中txManager属性指定事务管理器。

 

 

4.3、配置DAO Bean：

 

java代码：
查看 复制到剪贴板 打印
  1. <bean id="abstractDao" abstract="true">  
  2.     <property name="entityManagerFactory" ref="entityManagerFactory"/>  
  3. </bean>     
  4. <bean id="userDao"  
  5.       class="cn.javass.spring.chapter8.dao.jpa.UserJpaDaoImpl"  
  6.       parent="abstractDao"/>   

首先定义抽象的abstractDao，其有一个entityManagerFactory属性，从而可以让继承的子类自动继承entityManagerFactory属性注入；然后定义userDao，且继承abstractDao，从而继承entityManagerFactory注入；我们在此给配置文件命名为applicationContext-jpa.xml表示JPA实现。

 

 

5、最后测试一下吧（cn.javass.spring.chapter8. JPATest）：

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testBestPractice() {  
  3.     String[] configLocations = new String[] {  
  4.             "classpath:chapter7/applicationContext-resources.xml",  
  5.             "classpath:chapter8/applicationContext-jpa.xml"};  
  6.     ApplicationContext ctx = new ClassPathXmlApplicationContext(configLocations);  
  7.     IUserDao userDao = ctx.getBean(IUserDao.class);  
  8.     UserModel model = new UserModel();  
  9.     model.setMyName("test");  
  10.     userDao.save(model);  
  11.     Assert.assertEquals(1, userDao.countAll());  
  12. }  

 

和Spring JDBC框架的最佳实践完全一样，除了使用applicationContext-jpa.xml代替了applicationContext-jdbc.xml，其他完全一样。也就是说，DAO层的实现替换可以透明化。

还有与集成其他ORM框架不同的是JPA在进行持久化或更新数据库操作时需要事务支持。

 

 

8.4.4  Spring+JPA的CRUD

Spring+JPA CRUD（增删改查）也相当简单，让我们直接看具体示例吧：

 

 

java代码：
查看 复制到剪贴板 打印
  1. @Test  
  2. public void testCRUD() {  
  3.     PlatformTransactionManager txManager = ctx.getBean(PlatformTransactionManager.class);  
  4.     final JpaTemplate jpaTemplate = new JpaTemplate(entityManagerFactory);  
  5.     TransactionTemplate tansactionTemplate = new TransactionTemplate(txManager);  
  6.     tansactionTemplate.execute(new TransactionCallback<Void>() {  
  7.         @Override  
  8.         public Void doInTransaction(TransactionStatus status) {  
  9.             UserModel model = new UserModel();  
  10.             model.setMyName("test");  
  11.             //新增  
  12.             jpaTemplate.persist(model);  
  13.             //修改  
  14.             model.setMyName("test2");  
  15.             jpaTemplate.flush();//可选  
  16.             //查询  
  17.             String sql = "from UserModel where myName=?";  
  18.             List result = jpaTemplate.find(sql, "test2");  
  19.             Assert.assertEquals(1, result.size());  
  20.             //删除  
  21.             jpaTemplate.remove(model);  
  22.             return null;  
  23.         }  
  24.     });  
  25. }  
  • 对于增删改必须运行在事务环境，因此我们使用TransactionTemplate事务模板类来支持事务。
  • 持久化：使用JpaTemplate 类的persist方法持久化模型对象；
  • 更新：对于持久化状态的模型对象直接修改属性，调用flush方法即可更新到数据库，在一些场合时flush方法调用可选，如执行一个查询操作等，具体请参考相关文档；
  • 查询：可以使用find方法执行JPA QL查询；
  • 删除：使用remove方法删除一个持久化状态的模型对象。

       Spring集成JPA进行增删改查也相当简单，但本文介绍的稍微复杂一点，因为牵扯到编程式事务，如果采用声明式事务将和集成Hibernate方式一样简洁。

 

文章标签：
Java
Spring
数据库连接
数据库
SQL
关键词：
集成spring
集成jpa
集成jpa Spring
孤剑
目录
相关文章
游客zi3qmblbcdexu
|
1月前
|
Java Maven Docker
gitlab-ci 集成 k3s 部署spring boot 应用
gitlab-ci 集成 k3s 部署spring boot 应用
游客zi3qmblbcdexu
51 1
互联网课堂
|
3月前
|
资源调度 Java 调度
Spring Cloud Alibaba 集成分布式定时任务调度功能
定时任务在企业应用中至关重要，常用于异步数据处理、自动化运维等场景。在单体应用中，利用Java的`java.util.Timer`或Spring的`@Scheduled`即可轻松实现。然而，进入微服务架构后，任务可能因多节点并发执行而重复。Spring Cloud Alibaba为此发布了Scheduling模块，提供轻量级、高可用的分布式定时任务解决方案，支持防重复执行、分片运行等功能，并可通过`spring-cloud-starter-alibaba-schedulerx`快速集成。用户可选择基于阿里云SchedulerX托管服务或采用本地开源方案（如ShedLock）
互联网课堂
117 1
java冯坚持
|
30天前
|
前端开发 Java 程序员
springboot 学习十五：Spring Boot 优雅的集成Swagger2、Knife4j
这篇文章是关于如何在Spring Boot项目中集成Swagger2和Knife4j来生成和美化API接口文档的详细教程。
java冯坚持
50 1
程序员皮皮林
|
1月前
|
存储 前端开发 Java
Spring Boot 集成 MinIO 与 KKFile 实现文件预览功能
本文详细介绍如何在Spring Boot项目中集成MinIO对象存储系统与KKFileView文件预览工具，实现文件上传及在线预览功能。首先搭建MinIO服务器，并在Spring Boot中配置MinIO SDK进行文件管理；接着通过KKFileView提供文件预览服务，最终实现文档管理系统的高效文件处理能力。
程序员皮皮林
247 11
java冯坚持
|
30天前
|
Java Spring
springboot 学习十一：Spring Boot 优雅的集成 Lombok
这篇文章是关于如何在Spring Boot项目中集成Lombok，以简化JavaBean的编写，避免冗余代码，并提供了相关的配置步骤和常用注解的介绍。
java冯坚持
79 0
阿里云云原生
|
4月前
|
资源调度 Java 调度
Spring Cloud Alibaba 集成分布式定时任务调度功能
Spring Cloud Alibaba 发布了 Scheduling 任务调度模块 [#3732]提供了一套开源、轻量级、高可用的定时任务解决方案，帮助您快速开发微服务体系下的分布式定时任务。
阿里云云原生
14909 28
小王老师呀
|
3月前
|
消息中间件 安全 Java
Spring Boot 基于 SCRAM 认证集成 Kafka 的详解
【8月更文挑战第4天】本文详解Spring Boot结合SCRAM认证集成Kafka的过程。SCRAM为Kafka提供安全身份验证。首先确认Kafka服务已启用SCRAM，并准备认证凭据。接着，在`pom.xml`添加`spring-kafka`依赖，并在`application.properties`中配置Kafka属性，包括SASL_SSL协议与SCRAM-SHA-256机制。创建生产者与消费者类以实现消息的发送与接收功能。最后，通过实际消息传递测试集成效果与认证机制的有效性。
小王老师呀
132 4
JEECG
|
3月前
|
人工智能 Java API
JeecgBoot 低代码平台快速集成 Spring AI
Spring 通过 Spring AI 项目正式启用了 AI（人工智能）生成提示功能。本文将带你了解如何在 Jeecg Boot 应用中集成生成式 AI，以及 Spring AI 如何与模型互动，包含 RAG 功能。
JEECG
123 3
理想shi做条咸鱼
|
3月前
|
XML Java 数据库连接
Spring Boot集成MyBatis
主要系统的讲解了 Spring Boot 集成 MyBatis 的过程，分为基于 xml 形式和基于注解的形式来讲解，通过实际配置手把手讲解了 Spring Boot 中 MyBatis 的使用方式，并针对注解方式，讲解了常见的问题已经解决方式，有很强的实战意义。在实际项目中，建议根据实际情况来确定使用哪种方式，一般 xml 和注解都在用。
理想shi做条咸鱼
177 7
土木林森
|
3月前
|
测试技术 Java Spring
Spring 框架中的测试之道：揭秘单元测试与集成测试的双重保障，你的应用真的安全了吗？
【8月更文挑战第31天】本文以问答形式深入探讨了Spring框架中的测试策略，包括单元测试与集成测试的有效编写方法，及其对提升代码质量和可靠性的重要性。通过具体示例，展示了如何使用`@MockBean`、`@SpringBootTest`等注解来进行服务和控制器的测试，同时介绍了Spring Boot提供的测试工具，如`@DataJpaTest`，以简化数据库测试流程。合理运用这些测试策略和工具，将助力开发者构建更为稳健的软件系统。
土木林森
54 0

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    spring的AOP组件
  • 3
    深入实践Spring Boot3.2.4　删除控制器
  • 4
    配置springmvc在其他类中（spring容器外）获取注入bean
  • 5
    Spring中注入基本类型
  • 6
    Spring Cloud实战小贴士：Zuul统一异常处理（一）
  • 7
    Spring装配Bean---使用xml配置
  • 8
    Ehcache 整合Spring 使用页面、对象缓存
  • 9
    转：spring配置文件中xsd引用问题
  • 10
    面向切面的Spring
  • 1
    在jeecgboot中集成bpmn-process-designer流程设计器
    238
  • 2
    构建未来：Android与IoT设备的无缝集成
    128
  • 3
    数据库性能诊断工具DBdoctor通过阿里云PolarDB产品生态集成认证
    366
  • 4
    在SpringCloud2023中快速集成SpringCloudGateway网关
    151
  • 5
    【Docker 专栏】Docker 与容器化数据库的集成与优化
    236
  • 6
    【Docker 专栏】Docker 与云存储服务的集成
    85
  • 7
    在IntelliJ IDEA中通过Spring Boot集成达梦数据库：从入门到精通
    1388
  • 8
    基于混沌集成决策树的电能质量复合扰动识别（matlab代码）
    50
  • 9
    持续集成与持续部署（CI/CD）：提高软件开发效率的关键实践
    136
  • 10
    【Docker 专栏】Docker 与 CI/CD 的集成策略
    121

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第二阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • The Reactive Cloud Native Arch
  • 集成智能接入网关APP：优化企业级移动办公网络
  • 云效助力企业集成安全到DevOps中

    • 相关实验场景

    更多
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • Rocketmq-spring入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云OSS设置跨域访问