jpa+spring对实体的crud和实现分页功能的简单实用的封装

最新推荐文章于 2021-10-09 21:09:12 发布
最新推荐文章于 2021-10-09 21:09:12 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： web 文章标签： jpa spring string object null delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/drawtakes/article/details/4783785
版权
这篇博客介绍了如何利用JPA和Spring进行实体的CRUD操作，并封装了一个分页类QueryResult，实现了DAO接口，包括查询、删除、更新等方法，同时提供了分页查询的多种实现。示例中还包括了具体实体类ProductType的业务接口及其实现类，以及相关的配置文件和实体类设计。
摘要由CSDN通过智能技术生成

 

分页类的封装:

==============================================================================================

package com.itcast.bean;

import java.util.List;

/**
 * 对分页做一个单独的类来处理
 * 显而易见是结果集与总数的封装
 * @author Administrator
 *
 * @param <T>
 */
public class QueryResult<T> {

    private List<T> resultlist;
   
    private long totalrecord;

    public List<T> getResultlist() {
        return resultlist;
    }

    public void setResultlist(List<T> resultlist) {
        this.resultlist = resultlist;
    }

    public long getTotalrecord() {
        return totalrecord;
    }

    public void setTotalrecord(long totalrecord) {
        this.totalrecord = totalrecord;
    }
   
}

 

DAO的设计

==============================================================================================

package com.itcast.service.base;

import java.util.LinkedHashMap;

import com.itcast.bean.QueryResult;

public interface DAO {

    //保存
    public void save(Object entity);
    //更新
    public void update(Object entity);
    //删除
    public <T> void delete(Class<T> entityClass,Object entityid);
    //获取
    public <T> void delete(Class<T> entityClass,Object[] entityids);
    //查找
    public <T> T find(Class<T> entityClass,Object entityId);
   
    //获取分页数据
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult
            ,String wherejpql,Object[] queryParams,LinkedHashMap<String, String> orderby);
   
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult
            ,String wherejpql,Object[] queryParams);
   
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult
            ,LinkedHashMap<String, String> orderby);
   
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult);
   
    public <T> QueryResult<T> getScrollData(Class<T> entityClass);
   
}

 

 

抽象类的实现

==============================================================================================

package com.itcast.service.base;

import java.util.LinkedHashMap;

import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.itcast.bean.QueryResult;

@Transactional
public abstract class DaoSupport implements DAO {

    @PersistenceContext protected EntityManager em;
   
    public <T> void delete(Class<T> entityClass,Object entityid) {
        //em.remove(em.getReference(entityClass, entityid));
        delete(entityClass,new Object[]{entityid});
    }

    public <T> void delete(Class<T> entityClass,Object[] entityids) {
        for(Object id : entityids){
            em.remove(em.getReference(entityClass, id));
        }
    }

    @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
    public <T> T find(Class<T> entityClass, Object entityId) {
        return em.find(entityClass, entityId);
    }

    public void save(Object entity) {
        em.persist(entity);
    }

    public void update(Object entity) {
        em.merge(entity);
    }

    @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,
            int firstindex, int maxresult, LinkedHashMap<String, String> orderby) {
        return getScrollData(entityClass, firstindex, maxresult,null,null, orderby);
    }

    @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,
            int firstindex, int maxresult, String wherejpql,Object[] queryParams) {
        return getScrollData(entityClass, firstindex, maxresult, wherejpql, queryParams,null);
    }

    @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult) {
        return getScrollData(entityClass, firstindex, maxresult,null,null,null);
    }

    @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
    public <T> QueryResult<T> getScrollData(Class<T> entityClass) {
        return getScrollData(entityClass,-1,-1);
    }

   
    @SuppressWarnings("unchecked")
    @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
    public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult
            ,String wherejpql,Object[] queryParams,LinkedHashMap<String, String> orderby) {
        QueryResult qr = new QueryResult<T>();
        String entityname = getEntityName(entityClass);
        Query query = em.createQuery("select o from "+ entityname+ " o " +(wherejpql==null?" ":" where "+wherejpql) + buildOrderby(orderby));
        setQueryParams(query, queryParams);
        //实现分页设置开始索引和最大数据量
        if(firstindex != -1 && maxresult != -1){
            query.setFirstResult(firstindex).setMaxResults(maxresult);
        }
        qr.setResultlist(query.getResultList());
        query = em.createQuery("select count(o) from "+ entityname+ " o "+(wherejpql==null?" ":" where "+wherejpql));
        setQueryParams(query, queryParams);
        qr.setTotalrecord((Long)query.getSingleResult());
        System.out.println(qr);
        return qr;
    }
   
   
    protected void setQueryParams(Query query,Object[] queryParams){
        if(queryParams != null && queryParams.length>0){
            for(int i = 0; i<queryParams.length; ++i){
                query.setParameter(i+1, queryParams[i]);
            }
        }
    }

    //组装order by语句
   
    protected String buildOrderby(LinkedHashMap<String,String> orderby){
        StringBuffer orderbyql = new StringBuffer("");
        if(orderby != null && orderby.size()>0){
            orderbyql.append(" order by ");
            for(String key : orderby.keySet()){
                orderbyql.append("o.").append(key).append(" ").append(orderby.get(key)).append(",");
            }
            orderbyql.deleteCharAt(orderbyql.length()-1);
        }
        return orderbyql.toString();
    }
   
    //获取实体的名称
    protected <T> String getEntityName(Class<T> entityClass){
        String entityname = entityClass.getSimpleName();
        Entity entity = entityClass.getAnnotation(Entity.class);
        if(entity.name() != null && !"".equals(entity.name())){
            entityname = entity.name();
        }
        return entityname;
    }
}

 

 

具体实体类的业务接口

==============================================================================================

package com.itcast.service.product;

import com.itcast.bean.product.ProductType;
import com.itcast.service.base.DAO;

public interface ProductTypeService extends DAO{

}

 

 

具体实体类接口的实现类

==============================================================================================

package com.itcast.service.product.impl;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.itcast.bean.product.ProductType;
import com.itcast.service.base.DaoSupport;
import com.itcast.service.product.ProductTypeService;

@Service
@Transactional
public class ProductTypeServiceBeen extends DaoSupport implements ProductTypeService {

    /**
     * 重载DaoSupport的public <T> void delete(Class<T> entityClass, Object[] entityids)方法
     * 使其对ProductType实体类只是将他的visible设置为false而不像其他的实体呗删除掉
     */
    @Override
    public <T> void delete(Class<T> entityClass, Object[] entityids) {
        if(entityids!=null && entityids.length>0){
            StringBuffer jpql = new StringBuffer();
            for(int i=0;i<entityids.length;++i){
                jpql.append("?").append(i+2).append(",");
            }
            jpql.deleteCharAt(jpql.length()-1);
            Query query = em.createQuery("update ProductType o set o.visible=?1 where o.typeid in("+jpql.toString()+")")
                             .setParameter(1, false);
            for(int i=0;i<entityids.length;++i){
                query.setParameter(i+2, entityids[i]);
            }
            query.executeUpdate();
        }
    }

   
}

 

 

测试类

==============================================================================================

package junit.test;


import java.util.LinkedHashMap;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.itcast.bean.QueryResult;
import com.itcast.bean.product.ProductType;
import com.itcast.service.product.ProductTypeService;


public class ProductTest {
    private static ApplicationContext cxt;
    private static ProductTypeService productService;
   
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        try {
            cxt = new ClassPathXmlApplicationContext("beans.xml");
            productService = (ProductTypeService) cxt.getBean("productTypeServiceBeen");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

   
    @Test public void testSave(){
        for(int i = 0;i<20;++i){
            ProductType type = new ProductType();
            type.setName(i+"瑜伽用品");
            type.setNote("好产品");
            productService.save(type);
        }
    }
   
    @Test public void testFind(){
        ProductType type = productService.find(ProductType.class, 1);
        System.out.println(type);
        Assert.assertNotNull("找不到id为1的记录",type);
    }
   
    @Test public void testUpdate(){
        ProductType type = productService.find(ProductType.class, 1);
        type.setName("足球");
        type.setNote("好足球");
        productService.update(type);
    }
   
    @Test public void testDelete(){
        productService.delete(ProductType.class, 2);
    }
   
    @Test public void testgetScrollData(){
        LinkedHashMap<String, String> orderby = new LinkedHashMap<String, String>();
        orderby.put("typeid", "asc");
        QueryResult<ProductType> qr = productService.getScrollData(ProductType.class);
        for(ProductType t: qr.getResultlist()){
            System.out.println(t.getName());
        }
    }
}

 

 

实体类的设计

==============================================================================================

package com.itcast.bean.product;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;

import org.apache.tools.ant.util.facade.FacadeTaskHelper;

@Entity
public class ProductType implements Serializable{

    private static final long serialVersionUID = 1L;

    //类别id
    private Integer typeid;

    //类别名称
    private String name;
   
    //备注，用于Google搜索页面描述
    private String note;
   
    //是否可见
    private Boolean visible = true;
   
    //子类别
    private Set<ProductType> childtypes = new HashSet<ProductType>();
   
    //所属父类
    private ProductType parent;
   
    @OneToMany(cascade={CascadeType.REFRESH,CascadeType.REMOVE},mappedBy="parent")
    public Set<ProductType> getChildtypes() {
        return childtypes;
    }

    public void setChildtypes(Set<ProductType> childtypes) {
        this.childtypes = childtypes;
    }

    @ManyToOne(cascade=CascadeType.REFRESH)
    @JoinColumn(name="parentid")
    public ProductType getParent() {
        return parent;
    }

    public void setParent(ProductType parent) {
        this.parent = parent;
    }

    @Column(length=36,nullable=false)
    public String getName() {
        return name;
    }

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

    @Column(length=100,nullable=true)
    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }

    @Column(nullable=false)
    public Boolean getVisible() {
        return visible;
    }

    public void setVisible(Boolean visible) {
        this.visible = visible;
    }

    @Id @GeneratedValue(strategy=GenerationType.AUTO)
    public Integer getTypeid() {
        return typeid;
    }

    public void setTypeid(Integer typeid) {
        this.typeid = typeid;
    }
   
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((typeid == null) ? 0 : typeid.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ProductType other = (ProductType) obj;
        if (typeid == null) {
            if (other.typeid != null)
                return false;
        } else if (!typeid.equals(other.typeid))
            return false;
        return true;
    }

}

 

 

配置文件：

==============================================================================================

 

jpa的配置：META-INF/persistence.xml

 

<?xml version="1.0"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
<!-- file:///D:/hibernate/hibernate-entitymanager-3.3.2.CR1/resources/org/hibernate/ejb/persistence_1_0.xsd -->
  <persistence-unit name="itcast" transaction-type="RESOURCE_LOCAL" >
      <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
         <property name="hibernate.max_fetch_depth" value="3"/>
         <property name="hibernate.hbm2ddl.auto" value="update"/>
         <property name="hibernate.jdbc.fetch_size" value="18"/>
         <property name="hibernate.jdbc.batch_size" value="10"/>
         <property name="hibernate.show_sql" value="false"/>
         <property name="hibernate.format_sql" value="false"/>
      </properties>
  </persistence-unit>
</persistence>

 

Spring 的配置:beans.xml

 

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
        <!-- 使用注解的最重要语句 -->
        <context:annotation-config/>
        <context:component-scan base-package="com.itcast"/>
        <context:property-placeholder location="classpath:jdbc.properties"/>
       
 <bean id="dataSource" class="org.apache.commons.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}"/>
   <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
   <property name="maxIdle" value="${maxIdle}"/>
   <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请一些连接，以避免洪峰来时再申请而造成的性能开销 -->
   <property name="minIdle" value="${minIdle}"/>
   </bean>
 
   <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
         <property name="dataSource" ref="dataSource"/>
         <property name="persistenceXmlLocation" value="classpath:META-INF/persistence.xml"/>
         <property name="loadTimeWeaver">
             <bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"></bean>
         </property>
   </bean>
 
 
   <bean id = "transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
       <property name="entityManagerFactory" ref="entityManagerFactory"></property>
   </bean>
  <!-- 采用@Transactional注解方式声明处理事务 -->
  <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

==============================================================================================

 

jdbc.properties的配置:

driverClassName=org.gjt.mm.mysql.Driver
url=jdbc/:mysql/://localhost/:3306/ssh?useUnicode/=true&amp;characterEncoding/=UTF-8
username=root
password=123
initialSize=1
maxActive=100
maxIdle=8
minIdle=1

封装通用的Spring3+Struts2+JPA的CRUD 通用分页实现
11-21
"封装通用的Spring3+Struts2+JPA的CRUD 通用分页实现"是一个典型的Java Web开发实践，它结合了Spring框架的依赖注入、Struts2的MVC模式以及JPA（Java Persistence API）的数据持久层处理，来实现数据的创建、读取、...
Spring Data Jpa实现分页和排序代码实例
08-31
Spring Data Jpa实现分页和排序代码实例 Spring Data Jpa是一个基于Java持久化API（JPA）的数据访问技术，提供了对关系型数据库的访问和操作功能。在之前的学习中，我们学习了如何使用Jpa访问关系型数据库，但是...
jqGrid二次封装结合spring data jpa 分页查询
weixin_36193920的博客
06-22 764
写这篇文章主要是总结下项目中实际使用jqGrid的心得，文章思路主要分为两部分前端分页展示和后端分页查询。jqGrid首先需要的是官方的js，我们在项目中是进行了二次封装，为了保持整个项目的表格统一，快速开发。代码：前端：二次封装部分：（贴出来是为了方便像我一样的懒人，有些定制化的东西，可以参照jqGrid官方api在这个js里面加或者改或者可以选择不用，哈哈哈哈）/** * 封装了jqGrid...
SpringDataJpa之强大的手动分页查询(封装与技巧)
热门推荐
★【World Of Moshow 郑锴】★
06-12 1万+
背景 JPA对于简单类的查询还是不错的，但通常业务场景不会那么简单，必须用到sql语句来组成一些查询，这个时候我们最好就用手动分页了。 实体类 这是一个员工的实体，即将对他进行操刀 @Entity @NamedQuery(name=&amp;quot;Employee.findAll&amp;quot;, query=&amp;quot;SELECT e FROM Employee e&amp;quot;) public class Employee im...
使用jpa时分页查询封装pageable
qq_39787941的博客
06-24 1858
使用jpa时分页查询封装pageable public static Pageable makePageable(PageDto pageDto) { if (StringUtils.isBlank(pageDto.getSortColumn())) { return PageRequest.of(pageDto.getPage() - 1, pageDto.getLimit()); } else...
ireport 分页配置每也显示多少条_SpringBoot整合SpringDataJPA实现自定义查询以及分页查询...
weixin_39789094的博客
11-26 157
一、用@query实现自定义查询操作首先回忆一下，前面我们创建studentRepo类继承JpaRepository接口，即可实现最基本的crud。如下：那么我们要自定义查询怎么办呢？如下：我们定义了两类方法，这两类方法代表Repository使用的一种基本方法，@Query是用来配置自定义SQL的注解，通过这个声明，Spring Data JPA就知道该使用什么HQL去查询数据，?1表示用方法中...
用泛型与反射技术封装分页功能（JPA）
zsm653983的专栏
10-29 3678
DAO.java 　　public interface DAO { 　　/** 　　* 1.获取所要显示的分页数据(一般以list形式来存放) 　　* 2.获取记录的总数(计算总页数) 　　* 3.需要定义一个返回类型，获取两个参数 　　* @param 　　* @param entityClass 实体类 　　* @param firstindex 开始索引 　　* @param maxres
Spring3+Struts2+JPA实现CRUD通用分页封装技术
在标题中提到的Spring3，是实现CRUD和分页功能的基础，这些功能的实现将依赖于Spring的控制反转（IoC）容器和面向切面编程（AOP）技术。 #### Struts2 Struts2是一个基于MVC模式的Web应用框架，用于简化企业级Java ...
Spring data jpa 学习记录 CRUD 条件 分页 一对多 多对多
cyt
08-11 602
配置文件 spring boot 的配置文件 server: port: 8001 spring: datasource: url: jdbc:mysql:// ip /jpa?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull username: root password: 123456 driver-class-name: com.mysql.c.
Spring Data JPA + QueryDSL
weixin_46061449的博客
10-09 2296
Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！ Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现 这边主要介绍Spring Data JPA的一些用法： SpringBoot整合使用： ...
基于JPA的CRUD例子
01-05
基于JPA的CRUD例子
Spring Data JPA带条件分页查询实现原理
08-19
主要介绍了Spring Data JPA带条件分页查询实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JPA复杂查询加分页查询的快速开发
03-09
针对使用JPA方式操作数据库的复杂查询快速开发,复制代码直接使用,快速开发
JPA的动态分页查询(封装多个查询条件)
weixin_43078114的博客
04-25 2659
背景 查询应该考虑程序的扩展性，之前使用mybatis可以很简单的实现动态sql的拼接，springboot jpa如何实现这一功能呢？ 需求 可根据任务名称，任务状态，任务创建方式，用户查询方式，用户id的任务 ...
JPA 简单分页查询，封装用户id查询条件1（不手写SQL）
weixin_43078114的博客
03-14 842
环境 springboot+JPA 背景 JPA一般的增删改查都不需要手写SQL语句，使用其自己封装的方法就可以实现。分页及条件分页手写SQL当然也能实现，这里不作讨论，主要说说我在使用JPA自己封装的方法实现分页及条件分页的功能。 分页查询 步骤： 1.封装Pageable对象,参数有三个（当前页数、每页展示数据条数、根据数据库中哪个字段排序） 2.封装查询条件。本列中是要找到对应用户的任务信息...
自己实现一个JPA中的分页
WchStrife的博客
11-13 5654
前言最近有一个需求必须要使用原生SQL进行查询数据 这就带来了一个问题：没办法使用JPA直接传入Pageable对象进行分页查询 所以就需要自己实现一个类似JPA分页的功能 在查了源码之后也没有看到JPA到底是怎么实现的（如果有知道的请告诉我…） 所以自己封装了一个工具类来模拟了JPA的分页项目github地址：https://github.com/wchstrife/JPA-MyPageJ
Spring提供的JPA的分页的功能，和动态搜索后进行显示的分页功能的设置
有时间可以指导毕业设计，可以私聊我。一个热爱编程的smallCuteMonkey，可以私信我
06-29 266
在Dao层 中进行实现 JpaRepository<Blog,Long>，进行数据库操作的接口，JpaSpecificationExecutor 进行动态查询的接口 package com.sophomoreblog.blog.dao; import com.sophomoreblog.blog.po.Blog; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.
JPA工具类和CRUD操作实例
戴林峰的博客
07-17 457
/** * 解决实体管理器工厂的浪费资源和耗时问题 * 通过静态代码块的形式 ,当程序第一次访问此工具类时,创建一个公共的实体管理器工厂对象 * * 第一次访问getEntityManager方法,经过静态代码块创建一个factory对象,再调用方法创建一个EntityManager对象 * 第二次访问getEntityManager方法,直接通过已近创建好的factory对象,创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值