java面试题干货126-170

 1   <select id="foo" parameterType="Blog" resultType="Blog">
 2         select * from t_blog where 1 = 1
 3         <if test="title != null">
 4             and title = #{title}
 5         </if>
 6         <if test="content != null">
 7             and content = #{content}
 8         </if>
 9         <if test="owner != null">
10             and owner = #{owner}
11         </if>
12    </select>

 1  <select id="foo" parameterType="Blog" resultType="Blog">
 2         select * from t_blog where 1 = 1 
 3         <choose>
 4             <when test="title != null">
 5                 and title = #{title}
 6             </when>
 7             <when test="content != null">
 8                 and content = #{content}
 9             </when>
10             <otherwise>
11                 and owner = "owner1"
12             </otherwise>
13         </choose>
14     </select>

1  <select id="bar" resultType="Blog">
2         select * from t_blog where id in
3         <foreach collection="array" index="index" 
4             item="item" open="(" separator="," close=")">
5             #{item}
6         </foreach>
7     </select>

 1 import java.util.Collections;
 2 import java.util.HashMap;
 3 import java.util.Map;
 4 
 5 public class MyThreadLocal<T> {
 6     private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());
 7 
 8     public void set(T newValue) {
 9         map.put(Thread.currentThread(), newValue);
10     }
11 
12     public T get() {
13         return map.get(Thread.currentThread());
14     }
15 
16     public void remove() {
17         map.remove(Thread.currentThread());
18     }
19 }

 1 /**
 2  * 参考人员接口
 3  * @author 骆昊
 4  *
 5  */
 6 public interface Candidate {
 7 
 8     /**
 9      * 答题
10      */
11     public void answerTheQuestions();
12 }

 1 /**
 2  * 懒学生
 3  * @author 骆昊
 4  *
 5  */
 6 public class LazyStudent implements Candidate {
 7     private String name;        // 姓名
 8 
 9     public LazyStudent(String name) {
10         this.name = name;
11     }
12 
13     @Override
14     public void answerTheQuestions() {
15         // 懒学生只能写出自己的名字不会答题
16         System.out.println("姓名: " + name);
17     }
18 
19 }

 1 /**
 2  * 枪手
 3  * @author 骆昊
 4  *
 5  */
 6 public class Gunman implements Candidate {
 7     private Candidate target;   // 被代理对象
 8 
 9     public Gunman(Candidate target) {
10         this.target = target;
11     }
12 
13     @Override
14     public void answerTheQuestions() {
15         // 枪手要写上代考的学生的姓名
16         target.answerTheQuestions();
17         // 枪手要帮助懒学生答题并交卷
18         System.out.println("奋笔疾书正确答案");
19         System.out.println("交卷");
20     }
21 
22 }

1 public class ProxyTest1 {
2 
3     public static void main(String[] args) {
4         Candidate c = new Gunman(new LazyStudent("王小二"));
5         c.answerTheQuestions();
6     }
7 }

 1 import java.lang.reflect.InvocationHandler;
 2 import java.lang.reflect.Method;
 3 import java.util.List;
 4 
 5 public class ListProxy<T> implements InvocationHandler {
 6     private List<T> target;
 7 
 8     public ListProxy(List<T> target) {
 9         this.target = target;
10     }
11 
12     @Override
13     public Object invoke(Object proxy, Method method, Object[] args)
14             throws Throwable {
15         Object retVal = null;
16         System.out.println("[" + method.getName() + ": " + args[0] + "]");
17         retVal = method.invoke(target, args);
18         System.out.println("[size=" + target.size() + "]");
19         return retVal;
20     }
21 
22 }

 1 import java.lang.reflect.Proxy;
 2 import java.util.ArrayList;
 3 import java.util.List;
 4 
 5 public class ProxyTest2 {
 6 
 7     @SuppressWarnings("unchecked")
 8     public static void main(String[] args) {
 9         List<String> list = new ArrayList<String>();
10         Class<?> clazz = list.getClass();
11         ListProxy<String> myProxy = new ListProxy<String>(list);
12         List<String> newList = (List<String>) 
13                 Proxy.newProxyInstance(clazz.getClassLoader(), 
14                 clazz.getInterfaces(), myProxy);
15         newList.add("apple");
16         newList.add("banana");
17         newList.add("orange");
18         newList.remove("banana");
19     }
20 }

 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"  xmlns:p="http://www.springframework.org/schema/p"
 4     xmlns:p="http://www.springframework.org/schema/context"
 5      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 6      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 7 
 8      <context:component-scan base-package="com.jackfrued"/>
 9 
10      <bean id="propertyConfig"
11          class="org.springframework.beans.factory.config.
12   PropertyPlaceholderConfigurer">
13          <property name="location">
14              <value>jdbc.properties</value>
15          </property>
16      </bean>
17 
18      <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
19          <property name="driverClassName">
20              <value>${db.driver}</value>
21          </property>
22          <property name="url">
23              <value>${db.url}</value>
24          </property>
25          <property name="username">
26              <value>${db.username}</value>
27          </property>
28          <property name="password">
29              <value>${db.password}</value>
30          </property>
31      </bean>
32 
33      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
34          <property name="dataSource">
35              <ref bean="dataSource" />
36          </property>
37      </bean>
38 
39      <!-- JDBC事务管理器 -->
40      <bean id="transactionManager"
41          class="org.springframework.jdbc.datasource.
42        DataSourceTransactionManager"　scope="singleton">
43          <property name="dataSource">
44              <ref bean="dataSource" />
45          </property>
46      </bean>
47 
48      <!-- 声明事务模板 -->
49      <bean id="transactionTemplate"
50          class="org.springframework.transaction.support.
51    TransactionTemplate">
52          <property name="transactionManager">
53              <ref bean="transactionManager" />
54          </property>
55      </bean>
56 
57 </beans>

 1 package com.jackfrued.dao.impl;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.jdbc.core.JdbcTemplate;
 5 
 6 import com.jackfrued.dao.EmpDao;
 7 import com.jackfrued.entity.Emp;
 8 
 9 @Repository
10 public class EmpDaoImpl implements EmpDao {
11     @Autowired
12     private JdbcTemplate jdbcTemplate;
13 
14     @Override
15     public boolean save(Emp emp) {
16         String sql = "insert into emp values (?,?,?)";
17         return jdbcTemplate.update(sql, emp.getId(), emp.getName(), emp.getBirthday()) == 1;
18     }
19 
20 }

 1 package com.jackfrued.biz.impl;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Service;
 5 import org.springframework.transaction.TransactionStatus;
 6 import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 7 import org.springframework.transaction.support.TransactionTemplate;
 8 
 9 import com.jackfrued.biz.EmpService;
10 import com.jackfrued.dao.EmpDao;
11 import com.jackfrued.entity.Emp;
12 
13 @Service
14 public class EmpServiceImpl implements EmpService {
15     @Autowired
16     private TransactionTemplate txTemplate;
17     @Autowired
18     private EmpDao empDao;
19 
20     @Override
21     public void addEmp(final Emp emp) {
22         txTemplate.execute(new TransactionCallbackWithoutResult() {
23 
24             @Override
25             protected void doInTransactionWithoutResult(TransactionStatus txStatus) {
26                 empDao.save(emp);
27             }
28         });
29     }
30 
31 
32 }

 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:p="http://www.springframework.org/schema/p"
 5     xmlns:context="http://www.springframework.org/schema/context"
 6     xmlns:aop="http://www.springframework.org/schema/aop" 
 7     xmlns:tx="http://www.springframework.org/schema/tx"
 8     xsi:schemaLocation="http://www.springframework.org/schema/beans
 9            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
10            http://www.springframework.org/schema/context
11            http://www.springframework.org/schema/context/spring-context-3.2.xsd
12            http://www.springframework.org/schema/aop
13            http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
14            http://www.springframework.org/schema/tx
15            http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
16 
17     <!-- 配置由Spring IoC容器托管的对象对应的被注解的类所在的包 -->
18     <context:component-scan base-package="com.jackfrued" />
19 
20     <!-- 配置通过自动生成代理实现AOP功能 -->
21     <aop:aspectj-autoproxy />
22 
23     <!-- 配置数据库连接池 (DBCP) -->
24     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
25         destroy-method="close">
26         <!-- 配置驱动程序类 -->
27         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
28         <!-- 配置连接数据库的URL -->
29         <property name="url" value="jdbc:mysql://localhost:3306/myweb" />
30         <!-- 配置访问数据库的用户名 -->
31         <property name="username" value="root" />
32         <!-- 配置访问数据库的口令 -->
33         <property name="password" value="123456" />
34         <!-- 配置最大连接数 -->
35         <property name="maxActive" value="150" />
36         <!-- 配置最小空闲连接数 -->
37         <property name="minIdle" value="5" />
38         <!-- 配置最大空闲连接数 -->
39         <property name="maxIdle" value="20" />
40         <!-- 配置初始连接数 -->
41         <property name="initialSize" value="10" />
42         <!-- 配置连接被泄露时是否生成日志 -->
43         <property name="logAbandoned" value="true" />
44         <!-- 配置是否删除超时连接 -->
45         <property name="removeAbandoned" value="true" />
46         <!-- 配置删除超时连接的超时门限值(以秒为单位) -->
47         <property name="removeAbandonedTimeout" value="120" />
48         <!-- 配置超时等待时间(以毫秒为单位) -->
49         <property name="maxWait" value="5000" />
50         <!-- 配置空闲连接回收器线程运行的时间间隔(以毫秒为单位) -->
51         <property name="timeBetweenEvictionRunsMillis" value="300000" />
52         <!-- 配置连接空闲多长时间后(以毫秒为单位)被断开连接 -->
53         <property name="minEvictableIdleTimeMillis" value="60000" />
54     </bean>
55 
56     <!-- 配置Spring提供的支持注解ORM映射的Hibernate会话工厂 -->
57     <bean id="sessionFactory"
58         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
59         <!-- 通过setter注入数据源属性 -->
60         <property name="dataSource" ref="dataSource" />
61         <!-- 配置实体类所在的包 -->
62         <property name="packagesToScan" value="com.jackfrued.entity" />
63         <!-- 配置Hibernate的相关属性 -->
64         <property name="hibernateProperties">
65             <!-- 在项目调试完成后要删除show_sql和format_sql属性否则对性能有显著影响 -->
66             <value>
67                 hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
68             </value>
69         </property>
70     </bean>
71 
72     <!-- 配置Spring提供的Hibernate事务管理器 -->
73     <bean id="transactionManager"
74         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
75         <!-- 通过setter注入Hibernate会话工厂 -->
76         <property name="sessionFactory" ref="sessionFactory" />
77     </bean>
78 
79     <!-- 配置基于注解配置声明式事务 -->
80     <tx:annotation-driven />
81 
82 </beans>

 1 package com.jackfrued.dao;
 2 
 3 import java.io.Serializable;
 4 import java.util.List;
 5 
 6 import com.jackfrued.comm.QueryBean;
 7 import com.jackfrued.comm.QueryResult;
 8 
 9 /**
10  * 数据访问对象接口(以对象为单位封装CRUD操作)
11  * @author 骆昊
12  *
13  * @param <E> 实体类型
14  * @param <K> 实体标识字段的类型
15  */
16 public interface BaseDao <E, K extends Serializable> {
17 
18     /**
19      * 新增
20      * @param entity 业务实体对象
21      * @return 增加成功返回实体对象的标识
22      */
23     public K save(E entity);
24 
25     /**
26      * 删除
27      * @param entity 业务实体对象
28      */
29     public void delete(E entity);
30 
31     /**
32      * 根据ID删除
33      * @param id 业务实体对象的标识
34      * @return 删除成功返回true否则返回false
35      */
36     public boolean deleteById(K id);
37 
38     /**
39      * 修改
40      * @param entity 业务实体对象
41      * @return 修改成功返回true否则返回false
42      */
43     public void update(E entity);
44 
45     /**
46      * 根据ID查找业务实体对象
47      * @param id 业务实体对象的标识
48      * @return 业务实体对象对象或null
49      */
50     public E findById(K id);
51 
52     /**
53      * 根据ID查找业务实体对象
54      * @param id 业务实体对象的标识
55      * @param lazy 是否使用延迟加载
56      * @return 业务实体对象对象
57      */
58     public E findById(K id, boolean lazy);
59 
60     /**
61      * 查找所有业务实体对象
62      * @return 装所有业务实体对象的列表容器
63      */
64     public List<E> findAll();
65 
66     /**
67      * 分页查找业务实体对象
68      * @param page 页码
69      * @param size 页面大小
70      * @return 查询结果对象
71      */
72     public QueryResult<E> findByPage(int page, int size);
73 
74     /**
75      * 分页查找业务实体对象
76      * @param queryBean 查询条件对象
77      * @param page 页码
78      * @param size 页面大小
79      * @return 查询结果对象
80      */
81     public QueryResult<E> findByPage(QueryBean queryBean, int page, int size);
82 
83 }

 1 package com.jackfrued.dao;
 2 
 3 import java.io.Serializable;
 4 import java.util.List;
 5 
 6 import com.jackfrued.comm.QueryBean;
 7 import com.jackfrued.comm.QueryResult;
 8 
 9 /**
10  * BaseDao的缺省适配器
11  * @author 骆昊
12  *
13  * @param <E> 实体类型
14  * @param <K> 实体标识字段的类型
15  */
16 public abstract class BaseDaoAdapter<E, K extends Serializable> implements
17         BaseDao<E, K> {
18 
19     @Override
20     public K save(E entity) {
21         return null;
22     }
23 
24     @Override
25     public void delete(E entity) {
26     }
27 
28     @Override
29     public boolean deleteById(K id) {
30         E entity = findById(id);
31         if(entity != null) {
32             delete(entity);
33             return true;
34         }
35         return false;
36     }
37 
38     @Override
39     public void update(E entity) {
40     }
41 
42     @Override
43     public E findById(K id) {
44         return null;
45     }
46 
47     @Override
48     public E findById(K id, boolean lazy) {
49         return null;
50     }
51 
52     @Override
53     public List<E> findAll() {
54         return null;
55     }
56 
57     @Override
58     public QueryResult<E> findByPage(int page, int size) {
59         return null;
60     }
61 
62     @Override
63     public QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {
64         return null;
65     }
66 
67 }

  1 package com.jackfrued.dao;
  2 
  3 import java.io.Serializable;
  4 import java.lang.reflect.ParameterizedType;
  5 import java.util.ArrayList;
  6 import java.util.Collections;
  7 import java.util.List;
  8 
  9 import org.hibernate.Query;
 10 import org.hibernate.Session;
 11 import org.hibernate.SessionFactory;
 12 import org.springframework.beans.factory.annotation.Autowired;
 13 
 14 import com.jackfrued.comm.HQLQueryBean;
 15 import com.jackfrued.comm.QueryBean;
 16 import com.jackfrued.comm.QueryResult;
 17 
 18 /**
 19  * 基于Hibernate的BaseDao实现类
 20  * @author 骆昊
 21  *
 22  * @param <E> 实体类型
 23  * @param <K> 主键类型
 24  */
 25 @SuppressWarnings(value = {"unchecked"})
 26 public abstract class BaseDaoHibernateImpl<E, K extends Serializable> extends BaseDaoAdapter<E, K> {
 27     @Autowired
 28     protected SessionFactory sessionFactory;
 29 
 30     private Class<?> entityClass;       // 业务实体的类对象
 31     private String entityName;          // 业务实体的名字
 32 
 33     public BaseDaoHibernateImpl() {
 34         ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
 35         entityClass = (Class<?>) pt.getActualTypeArguments()[0];
 36         entityName = entityClass.getSimpleName();
 37     }
 38 
 39     @Override
 40     public K save(E entity) {
 41         return (K) sessionFactory.getCurrentSession().save(entity);
 42     }
 43 
 44     @Override
 45     public void delete(E entity) {
 46         sessionFactory.getCurrentSession().delete(entity);
 47     }
 48 
 49     @Override
 50     public void update(E entity) {
 51         sessionFactory.getCurrentSession().update(entity);
 52     }
 53 
 54     @Override
 55     public E findById(K id) {
 56         return findById(id, false);
 57     }
 58 
 59     @Override
 60     public E findById(K id, boolean lazy) {
 61         Session session = sessionFactory.getCurrentSession();
 62         return (E) (lazy? session.load(entityClass, id) : session.get(entityClass, id));
 63     }
 64 
 65     @Override
 66     public List<E> findAll() {
 67         return sessionFactory.getCurrentSession().createCriteria(entityClass).list();
 68     }
 69 
 70     @Override
 71     public QueryResult<E> findByPage(int page, int size) {
 72         return new QueryResult<E>(
 73             findByHQLAndPage("from " + entityName , page, size),
 74             getCountByHQL("select count(*) from " + entityName)
 75         );
 76     }
 77 
 78     @Override
 79     public QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {
 80         if(queryBean instanceof HQLQueryBean) {
 81             HQLQueryBean hqlQueryBean = (HQLQueryBean) queryBean;
 82             return new QueryResult<E>(
 83                 findByHQLAndPage(hqlQueryBean.getQueryString(), page, size, hqlQueryBean.getParameters()),
 84                 getCountByHQL(hqlQueryBean.getCountString(), hqlQueryBean.getParameters())
 85             );
 86         }
 87         return null;
 88     }
 89 
 90     /**
 91      * 根据HQL和可变参数列表进行查询
 92      * @param hql 基于HQL的查询语句
 93      * @param params 可变参数列表
 94      * @return 持有查询结果的列表容器或空列表容器
 95      */
 96     protected List<E> findByHQL(String hql, Object... params) {
 97         return this.findByHQL(hql, getParamList(params));
 98     }
 99 
100     /**
101      * 根据HQL和参数列表进行查询
102      * @param hql 基于HQL的查询语句
103      * @param params 查询参数列表
104      * @return 持有查询结果的列表容器或空列表容器
105      */
106     protected List<E> findByHQL(String hql, List<Object> params) {
107         List<E> list = createQuery(hql, params).list();
108         return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;
109     }
110 
111     /**
112      * 根据HQL和参数列表进行分页查询
113      * @param hql 基于HQL的查询语句
114      * @page 页码
115      * @size 页面大小
116      * @param params 可变参数列表
117      * @return 持有查询结果的列表容器或空列表容器
118      */
119     protected List<E> findByHQLAndPage(String hql, int page, int size, Object... params) {
120         return this.findByHQLAndPage(hql, page, size, getParamList(params));
121     }
122 
123     /**
124      * 根据HQL和参数列表进行分页查询
125      * @param hql 基于HQL的查询语句
126      * @page 页码
127      * @size 页面大小
128      * @param params 查询参数列表
129      * @return 持有查询结果的列表容器或空列表容器
130      */
131     protected List<E> findByHQLAndPage(String hql, int page, int size, List<Object> params) {
132         List<E> list = createQuery(hql, params)
133                 .setFirstResult((page - 1) * size)
134                 .setMaxResults(size)
135                 .list();
136         return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;
137     }
138 
139     /**
140      * 查询满足条件的记录数
141      * @param hql 基于HQL的查询语句
142      * @param params 可变参数列表
143      * @return 满足查询条件的总记录数
144      */
145     protected long getCountByHQL(String hql, Object... params) {
146         return this.getCountByHQL(hql, getParamList(params));
147     }
148 
149     /**
150      * 查询满足条件的记录数
151      * @param hql 基于HQL的查询语句
152      * @param params 参数列表容器
153      * @return 满足查询条件的总记录数
154      */
155     protected long getCountByHQL(String hql, List<Object> params) {
156         return (Long) createQuery(hql, params).uniqueResult();
157     }
158 
159     // 创建Hibernate查询对象(Query)
160     private Query createQuery(String hql, List<Object> params) {
161         Query query = sessionFactory.getCurrentSession().createQuery(hql);
162         for(int i = 0; i < params.size(); i++) {
163             query.setParameter(i, params.get(i));
164         }
165         return query;
166     }
167 
168     // 将可变参数列表组装成列表容器
169     private List<Object> getParamList(Object... params) {
170         List<Object> paramList = new ArrayList<>();
171         if(params != null) {
172             for(int i = 0; i < params.length; i++) {
173                 paramList.add(params[i]);
174             }
175         }
176         return paramList.size() == 0? Collections.EMPTY_LIST : paramList;
177     }
178 
179 }

 1 package com.jackfrued.comm;
 2 
 3 import java.util.List;
 4 
 5 /**
 6  * 查询条件的接口
 7  * @author 骆昊
 8  *
 9  */
10 public interface QueryBean {
11 
12     /**
13      * 添加排序字段
14      * @param fieldName 用于排序的字段
15      * @param asc 升序还是降序
16      * @return 查询条件对象自身(方便级联编程)
17      */
18     public QueryBean addOrder(String fieldName, boolean asc);
19 
20     /**
21      * 添加排序字段
22      * @param available 是否添加此排序字段
23      * @param fieldName 用于排序的字段
24      * @param asc 升序还是降序
25      * @return 查询条件对象自身(方便级联编程)
26      */
27     public QueryBean addOrder(boolean available, String fieldName, boolean asc);
28 
29     /**
30      * 添加查询条件
31      * @param condition 条件
32      * @param params 替换掉条件中参数占位符的参数
33      * @return 查询条件对象自身(方便级联编程)
34      */
35     public QueryBean addCondition(String condition, Object... params);
36 
37     /**
38      * 添加查询条件
39      * @param available 是否需要添加此条件
40      * @param condition 条件
41      * @param params 替换掉条件中参数占位符的参数
42      * @return 查询条件对象自身(方便级联编程)
43      */
44     public QueryBean addCondition(boolean available, String condition, Object... params);
45 
46     /**
47      * 获得查询语句
48      * @return 查询语句
49      */
50     public String getQueryString();
51 
52     /**
53      * 获取查询记录数的查询语句
54      * @return 查询记录数的查询语句
55      */
56     public String getCountString();
57 
58     /**
59      * 获得查询参数
60      * @return 查询参数的列表容器
61      */
62     public List<Object> getParameters();
63 }

 1 package com.jackfrued.comm;
 2 
 3 import java.util.List;
 4 
 5 /**
 6  * 查询结果
 7  * @author 骆昊
 8  *
 9  * @param <T> 泛型参数
10  */
11 public class QueryResult<T> {
12     private List<T> result;     // 持有查询结果的列表容器
13     private long totalRecords;  // 查询到的总记录数
14 
15     /**
16      * 构造器
17      */
18     public QueryResult() {
19     }
20 
21     /**
22      * 构造器
23      * @param result 持有查询结果的列表容器
24      * @param totalRecords 查询到的总记录数
25      */
26     public QueryResult(List<T> result, long totalRecords) {
27         this.result = result;
28         this.totalRecords = totalRecords;
29     }
30 
31     public List<T> getResult() {
32         return result;
33     }
34 
35     public void setResult(List<T> result) {
36         this.result = result;
37     }
38 
39     public long getTotalRecords() {
40         return totalRecords;
41     }
42 
43     public void setTotalRecords(long totalRecords) {
44         this.totalRecords = totalRecords;
45     }
46 }

 1 package com.jackfrued.dao;
 2 
 3 import com.jackfrued.comm.QueryResult;
 4 import com.jackfrued.entity.Dept;
 5 
 6 /**
 7  * 部门数据访问对象接口
 8  * @author 骆昊
 9  *
10  */
11 public interface DeptDao extends BaseDao<Dept, Integer> {
12 
13     /**
14      * 分页查询顶级部门
15      * @param page 页码
16      * @param size 页码大小
17      * @return 查询结果对象
18      */
19     public QueryResult<Dept> findTopDeptByPage(int page, int size);
20 
21 }

 1 package com.jackfrued.dao.impl;
 2 
 3 import java.util.List;
 4 
 5 import org.springframework.stereotype.Repository;
 6 
 7 import com.jackfrued.comm.QueryResult;
 8 import com.jackfrued.dao.BaseDaoHibernateImpl;
 9 import com.jackfrued.dao.DeptDao;
10 import com.jackfrued.entity.Dept;
11 
12 @Repository
13 public class DeptDaoImpl extends BaseDaoHibernateImpl<Dept, Integer> implements DeptDao {
14     private static final String HQL_FIND_TOP_DEPT = " from Dept as d where d.superiorDept is null ";
15 
16     @Override
17     public QueryResult<Dept> findTopDeptByPage(int page, int size) {
18         List<Dept> list = findByHQLAndPage(HQL_FIND_TOP_DEPT, page, size);
19         long totalRecords = getCountByHQL(" select count(*) " + HQL_FIND_TOP_DEPT);
20         return new QueryResult<>(list, totalRecords);
21     }
22 
23 }

 1 package com.jackfrued.comm;
 2 
 3 import java.util.List;
 4 
 5 /**
 6  * 分页器
 7  * @author 骆昊
 8  *
 9  * @param <T> 分页数据对象的类型
10  */
11 public class PageBean<T> {
12     private static final int DEFAUL_INIT_PAGE = 1;
13     private static final int DEFAULT_PAGE_SIZE = 10;
14     private static final int DEFAULT_PAGE_COUNT = 5;
15 
16     private List<T> data;           // 分页数据
17     private PageRange pageRange;    // 页码范围
18     private int totalPage;          // 总页数
19     private int size;               // 页面大小
20     private int currentPage;        // 当前页码
21     private int pageCount;          // 页码数量
22 
23     /**
24      * 构造器
25      * @param currentPage 当前页码
26      * @param size 页码大小
27      * @param pageCount 页码数量
28      */
29     public PageBean(int currentPage, int size, int pageCount) {
30         this.currentPage = currentPage > 0 ? currentPage : 1;
31         this.size = size > 0 ? size : DEFAULT_PAGE_SIZE;
32         this.pageCount = pageCount > 0 ? size : DEFAULT_PAGE_COUNT;
33     }
34 
35     /**
36      * 构造器
37      * @param currentPage 当前页码
38      * @param size 页码大小
39      */
40     public PageBean(int currentPage, int size) {
41         this(currentPage, size, DEFAULT_PAGE_COUNT);
42     }
43 
44     /**
45      * 构造器
46      * @param currentPage 当前页码
47      */
48     public PageBean(int currentPage) {
49         this(currentPage, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);
50     }
51 
52     /**
53      * 构造器
54      */
55     public PageBean() {
56         this(DEFAUL_INIT_PAGE, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);
57     }
58 
59     public List<T> getData() {
60         return data;
61     }
62 
63     public int getStartPage() {
64         return pageRange != null ? pageRange.getStartPage() : 1;
65     }
66 
67     public int getEndPage() {
68         return pageRange != null ? pageRange.getEndPage() : 1;
69     }
70 
71     public long getTotalPage() {
72         return totalPage;
73     }
74 
75     public int getSize() {
76         return size;
77     }
78 
79     public int getCurrentPage() {
80         return currentPage;
81     }
82 
83     /**
84      * 将查询结果转换为分页数据
85      * @param queryResult 查询结果对象
86      */
87     public void transferQueryResult(QueryResult<T> queryResult) {
88         long totalRecords = queryResult.getTotalRecords();
89 
90         data = queryResult.getResult();
91         totalPage = (int) ((totalRecords + size - 1) / size); 
92         totalPage = totalPage >= 0 ? totalPage : Integer.MAX_VALUE;
93         this.pageRange = new PageRange(pageCount, currentPage, totalPage);
94     }
95 
96 }

 1 package com.jackfrued.comm;
 2 
 3 /**
 4  * 页码范围
 5  * @author 骆昊
 6  *
 7  */
 8 public class PageRange {
 9     private int startPage;  // 起始页码
10     private int endPage;    // 终止页码
11 
12     /**
13      * 构造器
14      * @param pageCount 总共显示几个页码
15      * @param currentPage 当前页码
16      * @param totalPage 总页数
17      */
18     public PageRange(int pageCount, int currentPage, int totalPage) {
19         startPage = currentPage - (pageCount - 1) / 2;
20         endPage = currentPage + pageCount / 2;
21         if(startPage < 1) {
22             startPage = 1;
23             endPage = totalPage > pageCount ? pageCount : totalPage;
24         }
25         if (endPage > totalPage) {
26             endPage = totalPage;
27             startPage = (endPage - pageCount > 0) ? endPage - pageCount + 1 : 1;
28         }
29     }
30 
31     /**
32      * 获得起始页页码
33      * @return 起始页页码
34      */
35     public int getStartPage() {
36         return startPage;
37     }
38 
39     /**
40      * 获得终止页页码
41      * @return 终止页页码
42      */
43     public int getEndPage() {
44         return endPage;
45     }
46 
47 }

 1 package com.jackfrued.biz;
 2 
 3 import com.jackfrued.comm.PageBean;
 4 import com.jackfrued.entity.Dept;
 5 
 6 /**
 7  * 部门业务逻辑接口
 8  * @author 骆昊
 9  *
10  */
11 public interface DeptService {
12 
13     /**
14      * 创建新的部门
15      * @param department 部门对象
16      * @return 创建成功返回true否则返回false
17      */
18     public boolean createNewDepartment(Dept department);
19 
20     /**
21      * 删除指定部门
22      * @param id 要删除的部门的编号
23      * @return 删除成功返回true否则返回false
24      */
25     public boolean deleteDepartment(Integer id);
26 
27     /**
28      * 分页获取顶级部门
29      * @param page 页码
30      * @param size 页码大小
31      * @return 部门对象的分页器对象
32      */
33     public PageBean<Dept> getTopDeptByPage(int page, int size);
34 
35 }

 1 package com.jackfrued.biz.impl;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Service;
 5 import org.springframework.transaction.annotation.Transactional;
 6 
 7 import com.jackfrued.biz.DeptService;
 8 import com.jackfrued.comm.PageBean;
 9 import com.jackfrued.comm.QueryResult;
10 import com.jackfrued.dao.DeptDao;
11 import com.jackfrued.entity.Dept;
12 
13 @Service
14 @Transactional  // 声明式事务的注解
15 public class DeptServiceImpl implements DeptService {
16     @Autowired
17     private DeptDao deptDao;
18 
19     @Override
20     public boolean createNewDepartment(Dept department) {
21         return deptDao.save(department) != null;
22     }
23 
24     @Override
25     public boolean deleteDepartment(Integer id) {
26         return deptDao.deleteById(id);
27     }
28 
29     @Override
30     public PageBean<Dept> getTopDeptByPage(int page, int size) {
31         QueryResult<Dept> queryResult = deptDao.findTopDeptByPage(page, size);
32         PageBean<Dept> pageBean = new PageBean<>(page, size);
33         pageBean.transferQueryResult(queryResult);
34         return pageBean;
35     }
36 
37 }

 1 <context-param>
 2     <param-name>contextConfigLocation</param-name>
 3     <param-value>classpath:applicationContext.xml</param-value>
 4 </context-param>
 5 
 6 <listener>
 7     <listener-class>
 8         org.springframework.web.context.ContextLoaderListener
 9     </listener-class>
10 </listener>

 1 <web-app>
 2 
 3     <servlet>
 4         <servlet-name>example</servlet-name>
 5         <servlet-class>
 6             org.springframework.web.servlet.DispatcherServlet
 7         </servlet-class>
 8         <load-on-startup>1</load-on-startup>
 9     </servlet>
10 
11     <servlet-mapping>
12         <servlet-name>example</servlet-name>
13         <url-pattern>*.html</url-pattern>
14     </servlet-mapping>
15 
16 </web-app>

1 <bean id="dataSource"
2         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
3     <property name="driverClassName" value="${jdbc.driverClassName}"/>
4     <property name="url" value="${jdbc.url}"/>
5     <property name="username" value="${jdbc.username}"/>
6     <property name="password" value="${jdbc.password}"/>
7 </bean>
8 
9 <context:property-placeholder location="jdbc.properties"/>

1 <bean id="dataSource"
2         class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
3     <property name="driverClass" value="${jdbc.driverClassName}"/>
4     <property name="jdbcUrl" value="${jdbc.url}"/>
5     <property name="user" value="${jdbc.username}"/>
6     <property name="password" value="${jdbc.password}"/>
7 </bean>
8 
9 <context:property-placeholder location="jdbc.properties"/>

 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:aop="http://www.springframework.org/schema/aop"
 5      xmlns:tx="http://www.springframework.org/schema/tx"
 6      xsi:schemaLocation="
 7      http://www.springframework.org/schema/beans
 8      http://www.springframework.org/schema/beans/spring-beans.xsd
 9      http://www.springframework.org/schema/tx
10      http://www.springframework.org/schema/tx/spring-tx.xsd
11      http://www.springframework.org/schema/aop
12      http://www.springframework.org/schema/aop/spring-aop.xsd">
13 
14   <!-- this is the service object that we want to make transactional -->
15   <bean id="fooService" class="x.y.service.DefaultFooService"/>
16 
17   <!-- the transactional advice -->
18   <tx:advice id="txAdvice" transaction-manager="txManager">
19   <!-- the transactional semantics... -->
20   <tx:attributes>
21     <!-- all methods starting with ‘get‘ are read-only -->
22     <tx:method name="get*" read-only="true"/>
23     <!-- other methods use the default transaction settings (see below) -->
24     <tx:method name="*"/>
25   </tx:attributes>
26   </tx:advice>
27 
28   <!-- ensure that the above transactional advice runs for any execution
29     of an operation defined by the FooService interface -->
30   <aop:config>
31   <aop:pointcut id="fooServiceOperation" 
32     expression="execution(* x.y.service.FooService.*(..))"/>
33   <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>
34   </aop:config>
35 
36   <!-- don‘t forget the DataSource -->
37   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
38     destroy-method="close">
39   <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
40   <property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/>
41   <property name="username" value="scott"/>
42   <property name="password" value="tiger"/>
43   </bean>
44 
45   <!-- similarly, don‘t forget the PlatformTransactionManager -->
46   <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
47   <property name="dataSource" ref="dataSource"/>
48   </bean>
49 
50   <!-- other <bean/> definitions here -->
51 
52 </beans>

 1 package com.jackfrued.bean;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Component;
 5 
 6 @Component
 7 public class Person {
 8     private String name;
 9     private int age;
10     @Autowired
11     private Car car;
12 
13     public Person(String name, int age) {
14         this.name = name;
15         this.age = age;
16     }
17 
18     public void setCar(Car car) {
19         this.car = car;
20     }
21 
22     @Override
23     public String toString() {
24         return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
25     }
26 
27 }

 1 package com.jackfrued.bean;
 2 
 3 import org.springframework.stereotype.Component;
 4 
 5 @Component
 6 public class Car {
 7     private String brand;
 8     private int maxSpeed;
 9 
10     public Car(String brand, int maxSpeed) {
11         this.brand = brand;
12         this.maxSpeed = maxSpeed;
13     }
14 
15     @Override
16     public String toString() {
17         return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
18     }
19 
20 }

 1 package com.jackfrued.config;
 2 
 3 import org.springframework.context.annotation.Bean;
 4 import org.springframework.context.annotation.Configuration;
 5 
 6 import com.jackfrued.bean.Car;
 7 import com.jackfrued.bean.Person;
 8 
 9 @Configuration
10 public class AppConfig {
11 
12     @Bean
13     public Car car() {
14         return new Car("Benz", 320);
15     }
16 
17     @Bean
18     public Person person() {
19         return new Person("骆昊", 34);
20     }
21 }

 1 package com.jackfrued.test;
 2 
 3 import org.springframework.context.ConfigurableApplicationContext;
 4 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 5 
 6 import com.jackfrued.bean.Person;
 7 import com.jackfrued.config.AppConfig;
 8 
 9 class Test {
10 
11     public static void main(String[] args) {
12         // TWR (Java 7+)
13         try(ConfigurableApplicationContext factory = new AnnotationConfigApplicationContext(AppConfig.class)) {
14             Person person = factory.getBean(Person.class);
15             System.out.println(person);
16         }
17     }
18 }

1 WebApplicationContext ctx = 
2 WebApplicationContextUtils.getWebApplicationContext(servletContext);