weixin_30483495
weixin_30483495

JPA

  • 查询语言：Query Language
    • 条件表达式：where+having+on
      • 输入参数：支持位置参数 ?1，和命名参数 :userName，但这两者不能混用
      • 条件组合：属性导航：user.userName，一元运算 + -，逻辑操作 NOT AND OR，
        比较Comparison：= > >= < <= <>
        区间Between：[NOT] BETWEEN，支持数字、字符串、日期
        集合In：[NOT] IN，f in ('a', 'b') 等价于 f='a' or f='b'
        相似Like：[NOT] LIKE，支持单个字符_、多个字符%、转义字符\_
        空值Null：IS [NOT] NULL，
        空集合：IS [NOT] EMPTY，select o from Order o where o.lineItems is empty，
        集合成员：[NOT] MEMBER OF，select p from Person p where 'Joe' member of p.nicknames;
        存在性Exist：[NOT] EXISTS，select emp from Employee emp where exists ( select spouseEmp from Employee spouseEmp where spouseEmp = emp.spouse );//spouse配偶
        全部或任意：All+Any+Some，select emp from Employee where emp.salary > All { select m.salary from Manager m where m.department=emp.department };//部门高新员工
        子查询Subquery：select goodCustomer from Customer goodCustomer where goodCustomer.balanceOwed < ( select avg(c.balanceOwed)/2.0 from Customer c );//优质客户
      • 原生标准操作
        字符串：concat，substr，trim，lower，
        算术：abs，sqrt，mod，size，index（select w.name from Course c join c.studentsWaitlist w where c.name='Calculus' and index(w)=0;）
        聚合：count，max，min，avg，sum，distinct
        日期：current_date，current_time，current_timestamp
        过程调用：select c from Customer c where function( 'hasGoodCredit', c.balance, c.creditLimit );
        分支语句：update Employee e set e.salary = 
        case e.rating when 1 then e.salary*1.1
                              when 2 then e.salary*1.05
                              else e.salary*1.01
        end
        类型判断：select e from Employee e where type(e) in ( Exempt, Contractor )
    • 分组和结果限定
      select c.status, avg(c.filledOrderCount), count(c) from Customer c group by c.status having c.status in ( 1, 2 );//统计状态1和2的客户信息
      select c, count(o) from Customer c Join c.orders o group by c having count(o) >= 5;//查询订单数大于等于5的客户
    • 排序
      select o from Customer c JOIN c.orders o JOIN c.address a where a.state='CA' order by o.quantity DESC, o.totalcost;//总量倒序，花费升序
    • 批量更新和删除
      delete from Customer c where c.status='inactive' and c.orders is empty;//删除未激活且没有订单的用户
      update Employee e set e.address.building=22 where e.address.building=14 and e.project='Java EE';//修改Java EE项目组成员的地址
  • 查询条件：Criteria，标准条件
    • CriteriaBuilder，@PersistenceUnit EntityManagerFactory.getCriteriaBuilder(); 或 @PersistenceContext EntityManager.getCriteriaBuilder();
      CriteriaQuery createQuery(Class resultClass);//创建查询，返回结果类型为resultClass
      CriteriaQuery createTupleQuery();//创建查询，返回元组类型，Tuple包含多个TupleElements
      CriteriaUpdate createCriteriaUpdate(Class targetEntity);//创建对targetEntity的批量修改操作
      CriteriaDelete createCriteriaDelete(Class targetEntity);//创建对targetEntity的批量删除操作
      CompoundSelection tuple(Selection... selections);//创建tupe-valued查询
      CompoundSelection array(Selection... selections);//创建array-valued查询
      Order asc(Expression x);//创建表达式值的升序，desc为降序
      Expression avg(Expression x);//计算平均值，还有count[Distinct]，sum，max+min（数字），greatest+least（字符串、日期等），
      Predicate exists(Subquery subquery);//判断子查询是否存在，还有all，some，any，isTrue，isFalse，is[Not]Null
      Predicate and(Expression x, Expression y);//逻辑与，还有or，not
      Predicate or(Predicate... restrictions);//多个条件或，还有与and
      Predicate conjunction();//条件与，没有时返回true；还有disjunction，条件或，没有时返回false；
      Predicate equal(Expression x, Expression y);//判断是否相等，还有greaterThan[OrEqualTo]（Comparable），between，gt+ge+lt+le（Number）
      Predicate notEqual(Expression x, Object value);//判断是否不等，还有lessThan[OrEqualTo]，like+notLike
      Expression sum(Expression x, N y);//算术运算，还有neg+abs+prod积+diff差+quot商+mod模+sqrt平方根+concat+substring+trim+upper+length+locate
      Expression toLong(Expression x);//类型转换，还有Integer+Float+Double+BigDecimal+BigInteger+String
      Expression literal(T value);//转换常量值，
      Predicate is[Not]Empty(Expression collection);//测试集合非空，还有size+is[Not]Member，q.where(cb.isEmpty(order.get("lineItems"))); => where order.lineItems is empty
      Expression> values(M map);//从map的values()创建集合条件，还有keys
      Expression currentDate();//当前日期，还有java.sql.Time=currentTime，java.sql.Timestamp=currentTimestamp
      In in(Expression expression);//q.having( cb.in( customer.get("status").value(1).value(2) ) ); => having c.status in ( 1,2 )
    • CriteriaQuery -> AbstractQuery
      Root from(Class entityClass);//获得查询根，或与已有根计算笛卡尔积
      AbstractQuery where(Predicate... restrictions);//限定条件（替换之间的条件）
      AbstractQuery groupBy(Expression... grouping);//分组，还有having+orderBy
      CriteriaQuery select(Selection selection);//设置选择结果
      CriteriaQuery multiselect(Selection... selections);//多个选择结果
      执行复杂条件查询
      @PersistenceContext EntityManager em;
      TypedQuery query = em.createQuery(CriteriaQuery cq);//创建查询对象
      query.setFirstResult().setMaxResults().getResultList();//获得查询结果
    • CriteriaUpdate+CriteriaDelete，有from+where
      CriteriaUpdate set(Path attribute, X value);//更新属性

      update customer c set c.status='outstanding' where c.balance<1000;
      CriteriaUpdaate q=cb.createCriteriaUpdate(Customer.class);
      Root c=q.from(Customer.class);
      q.set(c.get("status"), "outstanding")
      .where( cb.lt(c.get("balance"), 1000) );
    • Root实体根+Join表连接 -> From查询 -> Path路径+Predicate与或 -> Expression表达式 -> Selection选择返回值
      Selection alias(String alias);//设置别名
      Predicate isNull();//是否空，还有isNotNull+
      Predicate in(Object... values);//集合元素，
      Path get(String attributeName);//获取路径
      Join join(String attributeName, JoinType type);//链接属性表，还有joinCollection，joinSet，joinList（t.index()限定多个对象的个数），joinMap（t.key()限定对象映射的key）
      Join on(Predicate... restrictions);//表链接
    • 查询样例，最好先组织SQL和JPQL语句，然后再翻译为对象方法调用
      • 获取全部或限定条件，select c from customer c where c.name="Jack";
        CriteriaQuery q = CriteriaBuilder.createQuery(Customer.class);//返回类型为Customer
        Root customer = q.from(Customer.class);//查询表Customer
        q.select(customer);//查询整个Customer对象
        q.where(cb.equal( customer.get("name"), 'Jack'));//限定name="Jack"的对象
      • 连接统计，select s.name, count(p) from Supplier s left join s.products on p.status='inStock' group by s.name;
        CriteriaQuery q = cb.createTupleQuery();//配合后面的multiselect
        Root s = q.from(Supplier.class);//
        Join p = s.join("products", JoinType.LEFT);//连接产品表
        p.on(cb.equal(p.get("status"), "inStock"));//限定连接条件，s.join("products", JoinType.LEFT).on(cb.equal(p.get("status"), "inStock"));
        q.groupBy( s.get("name") );
        q.multiselect( s.get("name"), cb.count(p) );//等价于q.select(cb.tuple(s.get("name"), cb.count(p)));，还有cb.array，cb.construct(Type.class, ... args)
      • 深度获取fetch join，select d from Department d left join fetch d.employees where d.deptno=1;
        CriteriaQuery q = cb.createQuery(Department.class);
        Root d = q.from(Department.class);
        d.fetch("employees", JoinType.LEFT);//查询结果中d.employees有值
        q.where( cb.equal(d.get("deptno"), 1) );
        q.select(d);
      • 路径导航，select p.vendor from Employee e join e.contactInfo.phones p where e.contactInfo.address.zipcode="95054";
        CriteriaQuery q = cb.createQuery;//返回结果为Vendor
        Root e = q.from(Employee.class);//从Employee开始查询
        Join phone = e.join("contactInfo").join("phones");//连接多张表
        q.where( cb.equal(e.get("contactInfo").get("address").get("zipcode"), "95054") );
        q.select( phone.get("vendor") );
      • 类型转换，select b.ISBN from Order o join treat(o.product AS Book) b;
        CriteriaQuery q = cb.createQuery(String.class);
        Root order = q.from(Order.class);
        Join book = cb.treat( order.join("product"), Book.class);
        q.select( book.get("isbn") );
      • 分支查询，
        select e.name ,
        case when e.rating=1 then e.salary*1.1
                when e.rating=2 then e.salary*1.2
                else e.salary&1.01
        from Employee e where e.department.name='Engineering';
        CriteriaQuery q=cb.createTupleQuery();
        Root e=q.from(Employee.class);
        q.where( cb.equal(e.get("department").get("name"), "Engineering") );
        q.multiselect( e.get("name"), cb.selectCase()
                                                             .when(cb.equal(e.get("rating"), 1), cb.prod(e.get("salary"), 1.1))
                                                             .when(cb.equal(e.get("rating"), 2), prod(e.get("salary"), 1.2))//这里需要常量的话调用cb.literal("value")
                                                             .otherWise(cb.prod(e.get("salary"), 1.01)) );
      • 参数
        select c from Customer c where c.status = :stat;
        CriteriaQuery q=cb.createQuery(Customer.class);
        Root c=q.from(Customer.class);
        ParameterExpression param=cb.parameter(Integer.class, "stat");
        q.select(c).where(cb.equal(c.get("status"), param));
      • 子查询，select goodCustomer from Customer goodCustomer where goodCustomer.balanceOwed < ( select avg(c.balanceOwed) from Customer c );
        CriteriaQuery q=cb.createQuery(Customer.class);
        Root goodCustomer=q.from(Customer.class);
        Subquery sq=q.subquery(Double.class);//子查询返回double值
        Root customer=sq.from(Customer.class);
        q.where(cb.lt(goodCustomer.get("balanceOwed"), sq.select(cb.avg(customer.get("balanceOwed")))));//goodCustomer.balanceOwed < avg(customer.balanceOwed)
        q.select(goodCustomer);

        select emp from Employee emp where emp.salary > all ( select m.salary from Manager m where m.department=emp.department );
        CriteriaQuery q=cb.createQuery(Employee.class);
        Root emp=q.from(Employee.class);
        Subquery sq=q.subquery(BigDecimal.class);
        Root manager=sq.from(Manager.class);
        sq.select(manager.get("salary"));
        sq.where(cb.equals(manager.get("department"), emp.get("department")));
        q.select(emp).where(cb.gt(emp.get("salary"), cb.all(sq)));
  • EntityManager
    • 获得EntityManager
      @PersistenceContext EntityManager em;
      @PersistenceUnit EntityManagerFactory emf; emf.createEntityManager()//
      javax.persistence.Persistence.createEntityManagerFactory("order");//从persistence.xml文件读取unit配置
  • 统计接口及实现：
    调用优先级Criteria API > Java Persistence Query Language > SQL
    有些统计语句可能是在很复杂只好执行原始的SQL语句了（sql条件需在可控范围内，最好检查一下参数安全性），但前两种在适当的时候还是应当多用的（防SQL注入）
    public class TongjiReposityImpl implements TongjiRepository {
        @PersistenceContext private EntityManager entityManager;
        @Override
        public CriteriaBuilder builder() { //Criteria API
            return entityManager.getCriteriaBuilder();
        }
        @Override
        public long count(CriteriaQuery query) {
            TypedQuery typedQuery = entityManager.createQuery(query);
            return typedQuery.getSingleResult();
        }
        @Override
        public Object[] sums(CriteriaQuery query) {
            List list = list(query, 0, 0);
            return list!=null && list.size()>0 ? list.get(0).toArray() : null;
        }
        @Override
        public List list(CriteriaQuery query, int firstResult, int maxResults) {
            TypedQuery typedQuery = entityManager.createQuery(query);
            typedQuery.setFirstResult(firstResult);
            if(maxResults>0) typedQuery.setMaxResults(maxResults);
            return typedQuery.getResultList();
        }
        @Override
        public int count(String jpql, Object... args) { //Java Persistence Query Language
            Query query = entityManager.createQuery(jpql);
            if(args!=null && args.length>0) {
                for(int i=0; ilength; i++) {
                    query.setParameter(i+1, args[i]);
                }
            }
            return ((Number)query.getSingleResult()).intValue();
        }
        @Override
        public Object[] sums(String jpql, Object... args) {
            List list = list(jpql, args);
            if(list!=null && list.size()>0) {
                Object obj = list.get(0);
                if(obj instanceof Object[]) {
                    return (Object[])obj;
                }else {
                    return new Object[] {obj};
                }
            }
            return null;
        }
        @Override
        public List list(String jpql, Object... args) {
            Query query = entityManager.createQuery(jpql);
            if(args!=null && args.length>0) {
                for(int i=0; ilength; i++) {
                    query.setParameter(i+1, args[i]);
                }
            }
            return query.getResultList();
        }
        @Override
        public int count(String sql) { //SQL
            Query query = entityManager.createNativeQuery(sql);
            return ((Number)query.getSingleResult()).intValue();
        }
        @Override
        public Object[] sums(String sql) {
            List list = list(sql);
            if(list!=null && list.size()>0) {
                Object obj = list.get(0);
                if(obj instanceof Object[]) {
                    return (Object[])obj;
                }else {
                    return new Object[] {obj};
                }
            }
            return null;
        }
        @Override
        public List list(String sql) {
            Query query = entityManager.createNativeQuery(sql);
            return query.getResultList();
        }
    }  
  • sql辅助生成工具类
    /**
     * select column from table where condition group by column having condition order by column limit from,length
     */
    public class SqlBuilder {
        private String select;
        private String from;
        private StringBuilder where = new StringBuilder();
        private String groupBy;
        private String having;
        private String orderBy;
        private String limit;
        
        public static SqlBuilder builder() {
            return new SqlBuilder();
        }
        
        /**
         * @param select
         * 
  • *
     * 
  • column1,column2,...
    •      * 
  • count(column1),sum(column2),avg(column3),...
    •      * 
  • user.id,user.name,account.amount,...
    •      */
        public SqlBuilder select(String select) {
            this.select = select;
            return this;
        }
        
        /**
         * @param from
         * 
  • ts_user
    •      * 
  • ts_user u left join ts_account a on u.ts_user_id = a.ts_user_id
    •      * 
  • jpql: TsUser user left join user.tsAccount account
    •      */
        public SqlBuilder from(String from) {
            this.from = from;
            return this;
        }
        
        /**
         * @param where
         * 
  • null, to reset where
    •      * 
  • name like '%Jack%'
    •      * 
  • id in (1,2,3)
    •      * 
  • exists (select a.id from acount a where a.user_id=user.id)
    •      * 
  • name is empty
    •      */
        public SqlBuilder where(String where) {
            if(StringUtils.isEmpty(where)) {
                this.where.setLength(0);
            }else {
                this.where.append(" and " + where);
            }
            return this;
        }
        
        /**
         * @param columnOperator
         * 
  • column1 >=
    •      * 
  • column2 !=
    •      */
        public SqlBuilder where(String columnOperator, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + columnOperator + " '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder groupBy(String groupBy) {
            this.groupBy = groupBy;
            return this;
        }
        
        public SqlBuilder having(String having) {
            this.having = having;
            return this;
        }
        
        public SqlBuilder orderBy(String orderBy) {
            this.orderBy = orderBy;
            return this;
        }
        
        /**
         * @param limit
         * 
  • limit 0,10
    •      */
        public SqlBuilder limit(String limit) {
            this.limit = limit;
            return this;
        }
        
        public SqlBuilder eq(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " = '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder ne(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " != '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder like(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " like '%" + sqlParam(value.toString()) + "%'");
            }
            return this;
        }
        
        public SqlBuilder notLike(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " not like '%" + sqlParam(value.toString()) + "%'");
            }
            return this;
        }
        
        public SqlBuilder in(String column, Collection value) {
            if(!CollectionUtils.isEmpty(value)) {
                where.append(" and " + column + " in (" + StringUtils.collectionToDelimitedString(value, ",", "'", "'") + ")");
            }
            return this;
        }
        
        public SqlBuilder notIn(String column, Collection value) {
            if(!CollectionUtils.isEmpty(value)) {
                where.append(" and " + column + " not in (" + StringUtils.collectionToDelimitedString(value, ",", "'", "'") + ")");
            }
            return this;
        }
        
        public SqlBuilder gt(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " > '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder gte(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " >= '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder lt(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " < '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder lte(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                where.append(" and " + column + " <= '" + sqlParam(value.toString()) + "'");
            }
            return this;
        }
        
        public SqlBuilder between(String column, Object from, Object to) {
            if(StringUtils.isEmpty(from) && StringUtils.isEmpty(to)) return this;
            if(!StringUtils.isEmpty(from)) where.append(" and " + column + " >= '" + sqlParam(from.toString()) + "'");
            else if(!StringUtils.isEmpty(to)) where.append(" and " + column + " <= '" + sqlParam(to.toString()) + "'");
            else where.append(" and " + column + " between '" + sqlParam(from.toString()) + "' and '" + sqlParam(to.toString()) + "'");
            return this;
        }
        
        public String sql() {
            if(select == null || from == null) //必须得有selece和from部分
                throw new RuntimeException("sql must contain select + from parts.");
            
            StringBuilder sql = new StringBuilder("select " + select+" from "+from);
            if(where.length() > 4) sql.append(" where " + where.substring(5));
            if(groupBy != null) sql.append(" group by " + groupBy);
            if(having != null) sql.append(" having " + having);
            if(orderBy != null) sql.append(" order by " + orderBy);
            if(limit != null) sql.append(" limit " + limit);
            return sql.toString();
        }
        //过滤掉引号'"，逗号,分号;注释号--等sql敏感符号
        public static String sqlParam(String sqlParam) {
            return sqlParam.replaceAll("([';]+|(--)+)", "");
        }
    }
  • jpql辅助工具类，与SqlBuilder类似
    public class JpqlBuilder {
        private String select;
        private String from;
        private StringBuilder where = new StringBuilder();
        private List args = new ArrayList();
        private String groupBy;
        private String having;
        private String orderBy;
        private String limit;
        
        public static JpqlBuilder builder() {
            return new JpqlBuilder();
        }
        
        /**
         * @param select
         * 
  • *
    •      * 
  • user.id,user.name,account.amount,...
    •      */
        public JpqlBuilder select(String select) {
            this.select = select;
            return this;
        }
        
        /**
         * @param from
         * 
  • jpql: TsUser user left join user.tsAccount account
    •      */
        public JpqlBuilder from(String from) {
            this.from = from;
            return this;
        }
        
        /**
         * @param where
         * 
  • null, to reset where
    •      * 
  • name like '%Jack%'
    •      */
        public JpqlBuilder where(String where) {
            if(StringUtils.isEmpty(where)) {
                this.where.setLength(0);
                args.clear();
            }else {
                this.where.append(" and " + where);
            }
            return this;
        }
        
        /**
         * @param columnOperator
         * 
  • column1 >=
    •      * 
  • column2 !=
    •      */
        public JpqlBuilder where(String columnOperator, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + columnOperator + " ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder groupBy(String groupBy) {
            this.groupBy = groupBy;
            return this;
        }
        
        public JpqlBuilder having(String having) {
            this.having = having;
            return this;
        }
        
        public JpqlBuilder orderBy(String orderBy) {
            this.orderBy = orderBy;
            return this;
        }
        
        /**
         * @param limit
         * 
  • limit 0,10
    •      */
        public JpqlBuilder limit(String limit) {
            this.limit = limit;
            return this;
        }
        
        public JpqlBuilder eq(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " = ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder ne(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " != ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder like(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " like ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder notLike(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " not like ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder in(String column, Collection value) {
            if(!CollectionUtils.isEmpty(value)) {
                where.append(" and " + column + " in (");
                boolean first = true;
                for(Object obj : value) {
                    args.add(obj);
                    if(first) {
                        first = false;
                        where.append("?"+args.size());
                    }else {
                        where.append(" , ?"+args.size());
                    }
                }
                where.append(")");
            }
            return this;
        }
        
        public JpqlBuilder notIn(String column, Collection value) {
            if(!CollectionUtils.isEmpty(value)) {
                where.append(" and " + column + " not in (");
                boolean first = true;
                for(Object obj : value) {
                    args.add(obj);
                    if(first) {
                        first = false;
                        where.append("?"+args.size());
                    }else {
                        where.append(" , ?"+args.size());
                    }
                }
                where.append(")");
            }
            return this;
        }
        
        public JpqlBuilder gt(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " > ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder gte(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " >= ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder lt(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " < ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder lte(String column, Object value) {
            if(!StringUtils.isEmpty(value)) {
                args.add(value);
                where.append(" and " + column + " <= ?" + args.size());
            }
            return this;
        }
        
        public JpqlBuilder between(String column, Object from, Object to) {
            if(StringUtils.isEmpty(from) && StringUtils.isEmpty(to)) return this;
            if(!StringUtils.isEmpty(from)) {
                args.add(from);
                where.append(" and " + column + " >= ?" + args.size());
            }else if(!StringUtils.isEmpty(to)) {
                args.add(to);
                where.append(" and " + column + " <= ?" + args.size());
            }else {
                args.add(from);
                args.add(to);
                where.append(" and " + column + " between ?" + (args.size()-1) + " and ?" + args.size());
            }
            return this;
        }
        
        public String jpql() {
            if(select == null || from == null) //必须得有selece和from部分
                throw new RuntimeException("sql must contain select + from parts.");
            
            StringBuilder sql = new StringBuilder("select " + select+" from "+from);
            if(where.length() > 4) sql.append(" where " + where.substring(5));
            if(groupBy != null) sql.append(" group by " + groupBy);
            if(having != null) sql.append(" having " + having);
            if(orderBy != null) sql.append(" order by " + orderBy);
            if(limit != null) sql.append(" limit " + limit);
            return sql.toString();
        }
        
        public Object[] args() {
            return args.toArray();
        }
    }  


    来自为知笔记(Wiz)


    转载于:https://www.cnblogs.com/xingqi/p/3929386.html

    你可能感兴趣的:(JPA)

    • 博客网站制作教程 2401_85194651 javamaven
      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    • Spring Data JPA kjcoder SpringDataJPA后端
      JPA概述JPA的全称是JavaPersistenceAPI，即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。JPA规范不干活，真正干活的是依托与它的实现方式(例：hibernate)。搭建环境（需求：保存客户）1.创建maven工程导入坐标org.hibernatehibernate-entitymanager2.需要配置jpa的核心配置文件*位
    • 搭建第一个SpringDataJPA工程 码来码去（未来可期） JavaWebjava
      第一步：创建maven工程，导入maven坐标使用SpringDataJPA，需要整合Spring与SpringDataJPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等4.2.4.RELEASE5.0.7.Final1.6.61.2.120.9.1.25.1.6junitjunit4.9testorg.aspect
    • ios runtime 简单路由 Mjs
      1.协议本路由通过协议方式实现首先定义一个必须实现的方法typedefvoid(^JCompletionHandler)(id_Nullableresult,NSError*_Nullableerror);@protocolJRouteHandler@required+(void)handleRequestWithParameters:(nullableJParameters)parameters
    • seata基本使用，柚子快报邀请码778899 登录成功
      把seata的使用在这里做了一个总结，希望能够帮助到大家。本案例在实施过程中，威哥力求简单明了，希望大家在学习过程中能够掌握其中的每个细节。好了，废话不多说，如果我们要学习seata，首先需要具备如下技术储备：数据库事务的基本知识；maven工具的使用；熟悉SpringCloudAlibaba技术栈；掌握SpringDataJPA简单使用；一.Seata基本概念1.seata是什么Seata是阿里
    • 基于spring boot的旅游管理系统 鹿屿二向箔 springboot旅游后端
      一个简单的SpringBoot应用的基础结构示例，以及如何设置一个基本的旅游管理系统。这个例子将包含用户注册和登录的基本功能。首先，你需要设置一个新的SpringBoot项目。可以通过SpringInitializr网站（https://start.spring.io/）来快速生成一个基础项目结构，选择必要的依赖项，比如Web、Thymeleaf、SpringDataJPA和MySQLDriver
    • 如何使用JPA自定义更新的sql语句实现对数据表的修改？——SpringDataJpa实现自定义（更新）update语句 海海不掉头发 笔记allsqlitesqlintellijideajapjpa
      文章目录前言一、DAO层/Mapper层二、Service业务处理层三、Controller控制层总结前言有的时候我们在后台管理系统中只需要修改一列的数据时，JPA的操作死对所有字段进行修改，这样就不太方便，而且SpringDataJpa的框架没有线程的更新方法，只能调用save()方法实行保存修改的数据。如果不想把其中一列的数据修改的话，那么JPA就会自动把这一列不想修改的数据默认null，并且
    • SpringBoot操作GBase8s数据库示例 迷你世界～爱丽丝
      SpringBoot+Hibernate(Jpa)操作GBase8s数据库示例GBase8s数据库是国产事务型数据库，目前已在各领域广泛应用，本篇使用当下主流的J2EE框架Springboot集成Hibernate（Jpa），对GBasse8S数据库CRUD操作进行讲解。1.技术点JPA是JAVA标准持久化API，是SUN公司推出的一套基于ORM的规范；Hibernate是对JPA（ORM规范）的
    • SpringData JPA之Respository接口的使用 OVA_Won SpringDatamysqljavaspring
      SpringDataJPA之Respository接口的使用Respository：最顶层的接口也是标志接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。准备工作导入JAR包：别忘了导入Junit测试包，否则后面没法单元测试编写Spring和数据库配置文件applicationContext.xml文件com.OVA.pojojdbc.propertiesjdbc.
    • 使用Spring Boot集成Spring Data JPA和单例模式构建库存管理系统 潘多编程 java
      引言在企业级应用开发中，数据库操作是非常重要的一环。SpringDataJPA提供了一种简化的方式来进行数据库交互，它使得开发者无需编写复杂的JPA代码就可以完成常见的CRUD操作。此外，设计模式如单例模式可以帮助我们更好地管理和控制对象的创建过程，从而提高系统的性能和可维护性。本文将展示如何结合SpringBoot、SpringDataJPA以及单例模式来构建一个基本的库存管理系统。环境准备在开
    • Spring常用中间件 贺仙姑 spring中间件java
      1.数据库中间件（1）MySQL:常用的关系型数据库，支持JDBC和JPA。（2）PostgreSQL:功能强大的开源关系型数据库，支持复杂查询。（3）MongoDB:NoSQL数据库，适合存储非结构化数据。（4）Redis:内存数据结构存储，常用于缓存和消息队列。2.消息队列（1）RabbitMQ:开源消息代理，支持多种消息协议，适合异步处理。（2）Kafka:分布式流处理平台，适合处理大规模数
    • 基于Java新媒体运营分析服务平台设计 什么任性 java新媒体运营springspringcloudSSM毕业设计html5
      一、引言随着新媒体行业的迅猛发展，内容创作、用户互动、广告投放等数据的分析变得至关重要。一个基于Java的新媒体运营分析服务平台，旨在整合多源数据，通过大数据处理和分析技术，为新媒体运营团队提供全面、实时的运营洞察。本平台设计旨在提高决策效率，优化内容策略，增强用户参与度，并最终提升品牌影响力和变现能力。二、技术栈和框架后端开发：SpringBoot（微服务架构）、SpringDataJPA（数据
    • java开发记录 T_Y9943 java开发语言
      24.9.6记录一下今天学到的注解,主要是@Api注解@Param详解SpringDataJPA查询结果为空时遇到的问题一个高级的java写法将list中3的值保存下来,重点在filter，此外还有map。Listintegers=list.stream().filter(e->e%3!=0).collect(Collectors.toList());Javalist移除元素JAP查询到的结果是P
    • SpringBoot学习（5）Spring boot Jpa使用 星河漫漫l springboot开发语言运维开发学习
      SpringBootJpa介绍首先了解Jpa是什么？Jpa(JavaPersistenceAPI)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，Jpa是在充分吸收了现有Hibe
    • SpringBoot2快速入门05--jpa 老鼠AI大米_Java全栈
      本节我们学习使用Jpa，jpa其实是一个规范，在出来之前，都是使用hibernate，hibernate可以使程序员以面向对象的方式操作数据库，我还是喜欢nativesql。先导入相关包，如下：compile('org.springframework.boot:spring-boot-starter-data-jpa')compile('mysql:mysql-connector-java')配置
    • Spring Data JPA-根据表生成代码 daqinzl SpringDataJPA代码自动生成freemarker
      参考资源https://blog.csdn.net/feiying0canglang/article/details/120643968，在此基础上丰富了repository，service，controller的模版。本文下载链接：https://download.csdn.net/download/daqinzl/89713067
    • SpringBoot 中怎么链接数据库并获取数据 爱掉发的小龙 javaspringbootspring经验分享后端
      在Spring框架中，有多种方式可以链接数据库并获取数据。常见的方式包括使用SpringJDBC、SpringDataJPA和SpringDataJDBC。以下是每种方式的简要说明和示例代码。###1.使用SpringJDBCSpringJDBC提供了一组方便的类，用于简化数据库访问。以下是使用SpringJDBC的步骤：####配置数据源首先，需要配置数据源。这可以在`application.p
    • JPA简介与实战 是Guava不是瓜娃 SSMjpa
      一、什么是JPAJPA：JavaPersistenceAPI，Java持久层API。是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。类似于JDBC，JPA是一组规范（接口），使应用程序以统一方式访问持久层。具体的实现：HibernateToplink其他ORM框架JPA和Hibernate的关系JPA是规范：JPA本质上就是一种ORM规范，不是ORM框架
    • java.lang.ClassNotFoundException: javax.xml.bind.JAXBException解决方案 xujia-Li 问题及解决方案JDK9.0JAXBAPI
      今天在学习springbootspringdatajpa时，出现了这个错误，错误日志如下：java.lang.IllegalStateException:FailedtoloadApplicationContextatorg.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(D
    • SpringBoot2--Spring Data JPA 笔记整理 Springboot
      前言SpringData项目的目的是为了简化构建基于Spring框架应用的数据访问技术，包括非关系数据库、Map-Reduce框架、云数据服务等等；另外也包含对关系数据库的访问支持。一、简介1、SpringData特点SpringData为我们提供使用统一的API来对数据访问层进行操作；这主要是SpringDataCommons项目来实现的。SpringDataCommons让我们在使用关系型或者
    • SpringBoot项目中使用SpringData-JPA持久化数据 火星刻苦的杏仁 springbootjavamybatis
      目录一、什么是JPA二、SpringData-JPA与MybatisPuls的区别三、项目中使用JPAJPA常用注解JPA进阶使用技巧一、什么是JPAJPA是JavaPersistenceAPI的简称，中文名Java持久层API，其设计目标主要是为了简化现有的持久化开发工作和整合ORM技术。简单地说，JPA就是为POJO（PlainOrdinaryJavaObject）提供持久化的标准规范，即将J
    • SpringBoot--整合JPA 吴声子夜歌 SpringBootJPASpringBootJPA整合
      SpringBoot整合JPA创建工程并导入依赖4.0.0pers.zhangspringboot_jpa1.0-SNAPSHOTorg.springframework.bootspring-boot-starter-parent1.5.9.RELEASEorg.springframework.bootspring-boot-starter-weborg.springframework.boots
    • Spring Data：JPA与Querydsl 光图强 java
      JPAJPA是java的一个规范，用于在java对象和数据库之间保存数据，充当面向对象领域模型和数据库之间的桥梁。它使用Hibernate、TopLink、IBatis等ORM框架实现持久性规范。SpringDataSpringData是Spring的一个子项目，用于简化数据库访问，支持NoSql数据和关系数据库。支持的NoSql数据库包括：Mongodb、redis、Hbase、Neo4j。Sp
    • Java Hibernate深度解析：11步精通ORM框架的艺术与安全 墨瑾轩 Java乐园javahibernate安全
      关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣第1章：引言：JPA与Hibernate的邂逅1.1什么是JPA？Hey，小伙伴们，欢迎来到JPA的奇妙世界！JPA，全称JavaPersistenceAPI，是一个让Java程序和数据库愉快玩耍的桥梁。想象一下，你有一个装满玩具的盒子，JPA就是帮你把玩具（
    • springboot中的@Cacheable缓存来增加手动分页的查询效率 为什么用手动分页业务用的jpa jpa中查了下没有数据库中间件 烟雨国度 springboot缓存数据库
      2024/7/319:45:09claude-3-opus-20240229当然可以！我们可以对代码进行进一步的优化，以提高性能。以下是一些优化建议：使用缓存机制：对于频繁查询的关键词或查询条件，可以考虑将查询结果缓存起来，避免重复查询数据库。可以使用Spring提供的缓存抽象（如@Cacheable、@CacheEvict等注解），或者使用第三方缓存库（如Redis）来实现缓存功能。优化正则表达
    • SpringBoot JPA Puny丶微芒
      定义JPA是JavaPersistenceAPI的简称，中文名Java持久层API，是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术：1.ORM映射元数据JPA支持XML和JDK注解两种元数据的形式，元数据描述对象和表之间的映射关系，
    • 使用jpa的@Query注解查询数据库中datatime类型数据报错Unknown column 'startTime' in 'where clause' JadeHanLiang 遇到的问题javajpa
      今天使用jpa的@Query这个注解查询数据时，sql语句语法出现了错误，记录下来。我的错误写法是这样的@Query(value="select*fromtbwhereDATE_FORMAT(start_time,'%Y-%m-%d')=DATE_FORMAT(startTime,'%Y-%m-%d')",nativeQuery=true)ListfindByStartTime(Datestart
    • Springboot+Mybatis+jpa+thymeleaf实现增删改查 柒麒 javaspringbootmybatis
      Springboot+Mybatis+jpa+thymeleaf项目结构pom文件Application配置文件实体类controller层实现类service层接口service层实现类dao层接口启动类index.html首页add.html添加页面update.html更新页面创建user表添加表数据首页展示添加修改删除总结项目结构pom文件配置相关依赖：UTF-8UTF-81.8org.s
    • 关于springboot持久层框架mybatis+jpa组合使用 小码农吗 日常栏目javamybatisspringbootmysql
      一、简介JPA和MyBatis各有各的好处，混合食用效果更佳。(hibernate是面向对象的，而MyBatis是面向关系的)个人总结（总结自己的理解）1.表关联较多的项目，优先使用mybatis2.持续维护开发迭代较快的项目建议使用mybatis，因为一般这种项目需要变化很灵活，对sql的灵活修改要求较高3.对于传统项目或者关系模型较为清晰稳定的项目，建议JPA（比如DDD设计中的领域层）4.目
    • SpringBoot + Mybatis/JPA jesus_H java
      这篇主要讲解SpringBoot结合JPA和Mybatis的使用SpringBoot作为后端框架，必定要对数据库进行crud操作，JPA和Mybatis把这些操作进行了封装，方便了代码的编写。JPA先从比较简单的JPA讲起第一步，添加依赖org.springframework.bootspring-boot-starter-data-jpamysqlmysql-connector-javaorg.
    • SQL的各种连接查询 xieke90 UNION ALLUNION外连接内连接JOIN
      一、内连接   概念：内连接就是使用比较运算符根据每个表共有的列的值匹配两个表中的行。                 内连接（join 或者inner join ）       SQL语法：       select * fron
    • java编程思想--复用类 百合不是茶 java继承代理组合final类
            复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书   一:组合语法:就是将对象的引用放到新类中即可     代码:     package com.wj.reuse; /** * * @author Administrator 组
    • [开源与生态系统]国产CPU的生态系统 comsci cpu
            计算机要从娃娃抓起...而孩子最喜欢玩游戏....       要让国产CPU在国内市场形成自己的生态系统和产业链,国家和企业就不能够忘记游戏这个非常关键的环节....       投入一些资金和资源,人力和政策,让游
    • JVM内存区域划分Eden Space、Survivor Space、Tenured Gen，Perm Gen解释 商人shang jvm内存
      jvm区域总体分两类，heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。 非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。 HotSpot虚拟机GC算法采用分代收
    • 页面上调用 QQ oloz qq
      <A href="tencent://message/?uin=707321921&amp;Site=有事Q我&amp;Menu=yes">   <img style="border:0px;" src=http://wpa.qq.com/pa?p=1:707321921:1></a>
    • 一些问题 文强chu 问题
      1.eclipse 导出 doc  出现“The Javadoc command does not exist.” javadoc command 选择 jdk/bin/javadoc.exe 2.tomcate 配置 web 项目 ..... SQL:3.mysql  * 必须得放前面 否则  select&nbs
    • 生活没有安全感 小桔子 生活孤独安全感
             圈子好小，身边朋友没几个，交心的更是少之又少。在深圳，除了男朋友，没几个亲密的人。不知不觉男朋友成了唯一的依靠，毫不夸张的说，业余生活的全部。现在感情好，也很幸福的。但是说不准难免人心会变嘛，不发生什么大家都乐融融，发生什么很难处理。我想说如果不幸被分手(无论原因如何)，生活难免变化很大，在深圳，我没交心的朋友。明
    • php 基础语法 aichenglong php 基本语法
      1 .1 php变量必须以$开头 <?php $a=” b”; echo ?> 1 .2 php基本数据库类型 Integer  float/double Boolean string 1 .3 复合数据类型 数组array和对象 object 1 .4 特殊数据类型  null 资源类型(resource)    $co
    • mybatis tools 配置详解 AILIKES mybatis
      MyBatis Generator中文文档 MyBatis Generator中文文档地址： http://generator.sturgeon.mopaas.com/ 该中文文档由于尽可能和原文内容一致，所以有些地方如果不熟悉，看中文版的文档的也会有一定的障碍，所以本章根据该中文文档以及实际应用，使用通俗的语言来讲解详细的配置。 本文使用Markdown进行编辑，但是博客显示效
    • 继承与多态的探讨 百合不是茶 JAVA面向对象 继承 对象
      继承 extends   多态 继承是面向对象最经常使用的特征之一：继承语法是通过继承发、基类的域和方法 //继承就是从现有的类中生成一个新的类，这个新类拥有现有类的所有extends是使用继承的关键字：     在A类中定义属性和方法； class A{ //定义属性 int age； //定义方法 public void go
    • JS的undefined与null的实例 bijian1013 JavaScriptJavaScript
      <form name="theform" id="theform"> </form> <script language="javascript"> var a alert(typeof(b)); //这里提示undefined if(theform.datas
    • TDD实践（一） bijian1013 java敏捷TDD
      一.TDD概述         TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。     
    • [Maven学习笔记十]Maven Profile与资源文件过滤器 bit1129 maven
      什么是Maven Profile Maven Profile的含义是针对编译打包环境和编译打包目的配置定制，可以在不同的环境上选择相应的配置，例如DB信息，可以根据是为开发环境编译打包，还是为生产环境编译打包，动态的选择正确的DB配置信息   Profile的激活机制 1.Profile可以手工激活，比如在Intellij Idea的Maven Project视图中可以选择一个P
    • 【Hive八】Hive用户自定义生成表函数(UDTF) bit1129 hive
      1. 什么是UDTF   UDTF，是User Defined Table-Generating Functions，一眼看上去，貌似是用户自定义生成表函数，这个生成表不应该理解为生成了一个HQL Table， 貌似更应该理解为生成了类似关系表的二维行数据集   2. 如何实现UDTF 继承org.apache.hadoop.hive.ql.udf.generic
    • tfs restful api 加auth 2.0认计 ronin47
      　　目前思考如何给tfs的ngx-tfs api增加安全性。有如下两点： 　　一是基于客户端的ip设置。这个比较容易实现。 　　二是基于OAuth2.0认证，这个需要lua，实现起来相对于一来说，有些难度。 　　现在重点介绍第二种方法实现思路。 　　 前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGe
    • jdk环境变量配置 byalias javajdk
      进行java开发，首先要安装jdk，安装了jdk后还要进行环境变量配置： 1、下载jdk（http://java.sun.com/javase/downloads/index.jsp），我下载的版本是：jdk-7u79-windows-x64.exe 2、安装jdk-7u79-windows-x64.exe 3、配置环境变量：右击"计算机"-->&quo
    • 《代码大全》表驱动法-Table Driven Approach-2 bylijinnan java
      package com.ljn.base; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.uti
    • SQL 数值四舍五入 小数点后保留2位 chicony 四舍五入
      1.round() 函数是四舍五入用，第一个参数是我们要被操作的数据，第二个参数是设置我们四舍五入之后小数点后显示几位。 2.numeric 函数的2个参数，第一个表示数据长度，第二个参数表示小数点后位数。 例如： 　　select   cast(round(12.5,2)   as   numeric(5,2))  
    • c++运算符重载 CrazyMizzz C++
      一、加+，减-，乘*，除/ 的运算符重载 Rational operator*(const Rational &x) const{ return Rational(x.a * this->a); } 在这里只写乘法的，加减除的写法类似 二、<<输出,>>输入的运算符重载      &nb
    • hive DDL语法汇总 daizj hive修改列DDL修改表
      hive DDL语法汇总 １、对表重命名 hive> ALTER TABLE table_name RENAME TO new_table_name;   2、修改表备注 hive> ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comm
    • jbox使用说明 dcj3sjt126com Web
      参考网址：http://www.kudystudio.com/jbox/jbox-demo.html jBox v2.3 beta [ 点击下载]  技术交流QQGroup：172543951 100521167 [2011-11-11] jBox v2.3 正式版 - [调整&修复] IE6下有iframe或页面有active、applet控件
    • UISegmentedControl 开发笔记 dcj3sjt126com
        //    typedef NS_ENUM(NSInteger, UISegmentedControlStyle) {     //        UISegmentedControlStylePlain,     // large plain   &
    • Slick生成表映射文件 ekian scala
      Scala添加SLICK进行数据库操作，需在sbt文件上添加slick-codegen包 "com.typesafe.slick" %% "slick-codegen" % slickVersion 因为我是连接SQL Server数据库，还需添加slick-extensions，jtds包 "com.typesa
    • ES-TEST gengzg test
      package com.MarkNum; import java.io.IOException; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.servlet.ServletException; import javax.servlet.annotation
    • 为何外键不再推荐使用 hugh.wang mysqlDB
      表的关联，是一种逻辑关系，并不需要进行物理上的“硬关联”，而且你所期望的关联，其实只是其数据上存在一定的联系而已，而这种联系实际上是在设计之初就定义好的固有逻辑。 在业务代码中实现的时候，只要按照设计之初的这种固有关联逻辑来处理数据即可，并不需要在数据库层面进行“硬关联”，因为在数据库层面通过使用外键的方式进行“硬关联”，会带来很多额外的资源消耗来进行一致性和完整性校验，即使很多时候我们并不
    • 领域驱动设计 julyflame VODAO设计模式DTOpo
      概念： VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对
    • 单例设计模式 hm4123660 javaSingleton单例设计模式懒汉式饿汉式
             单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。      &nb
    • logback zhb8015 loglogback
      一、logback的介绍      Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-class
    • 整合Kafka到Spark Streaming——代码示例和挑战 Stark_Summer sparkstormzookeeperPARALLELISMprocessing
      作者Michael G. Noll是瑞士的一位工程师和研究员，效力于Verisign，是Verisign实验室的大规模数据分析基础设施（基础Hadoop）的技术主管。本文，Michael详细的演示了如何将Kafka整合到Spark Streaming中。 期间， Michael还提到了将Kafka整合到 Spark Streaming中的一些现状，非常值得阅读，虽然有一些信息在Spark 1.2版
    • spring-master-slave-commondao 王新春 DAOspringdataSourceslavemaster
      互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。 为此，往往搭建 db的 一主多从库的 数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数