利用反射搭建项目的dao层，从此可以告别被人的dao层框架了（spring+反射）

作为一名刚入手的小白程序猿，不但"TA"不懂我们，就连自己都不懂自己，苦逼的程序猿，只能每天都是在给自己充电了。让"TA"和自己更了解。今天笔者又来吹吹水了，各位客官请买好零食咯，好了废话不多说了。
在以前做项目的时候，一般想到搭项目都是用别人的框架来做，但是别人的框架都是别人封装好的很多东西，对不太熟源码的码农来说就是苦逼呀，所以像笔者这种小白又不甘心，所以笔者就用反射来自己封装一个操作dao层的框架（不算一个框架，就是这么称呼吧），说起反射可能是很多像笔者这样的小白都不了解吧（不过好在笔者有点小聪明，自己学习一下）。其实大家在做项目时用的框架都是用反射来搭起来的，所以反射我们并不陌生，先不说太多了，怎么搭建自己dao层，笔者今天的实例子是用（spring+反射）搭建的Webapp,怎么入手呢 ，如下：
①：首先我们搭建springmvc的配置吧（笔者喜欢这样的方式呢）,先创建一个springmvc.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:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">

		<!--自动注解，扫描如下包 -->
        <mvc:annotation-driven/>
        <context:component-scan base-package="com.yw.Contrlloer"/>
        <bean class="org.springframework.web.servlet.mvc.support.ControllerBeanNameHandlerMapping"></bean>
</beans>

　　没错springmvc的配置文件就是这样简单就行了。

② 配好springmvc 接下来就是配置spring了 ，配spring的配置之前我们创建数据库的配置文件先 jdbc.properties。jdbc.properties的配置如下：

validationQuery=SELECT 1
	jdbc_URL=jdbc:mysql://127.0.0.1:3306/testredis?useUnicode=true&characterEncoding=UTF-8
	jdbc_username=root
	jdbc_password=123456
	initialSize=0
	maxActive=20
	maxIdle=20
	minIdle=0
	maxWait=6000
	timeBetweenEvictionRunsMillis=60000
	minEvictableIdleTimeMillis=25200000
	removeAbandonedTimeout=1800

　　然后就是spring的配置的文件了，对了笔者这里用的是阿里的连接池哦，为什么用阿里的，因为是阿里的（哈哈，是因为它强大呢） 配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">

  <context:annotation-config/>
  <context:component-scan base-package="com.yw.dao"/>
   <context:component-scan base-package="com.yw.service"/>
  <!-- 引入属性文件 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
      <property name="locations" value="classpath:com/yw/conf/config.properties"></property>
    </bean>

    <!-- 配置数据源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="url" value="${jdbc_URL}" />
		<property name="username" value="${jdbc_username}" />
		<property name="password" value="${jdbc_password}" />
		<!-- 初始化连接大小 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 连接池最大使用连接数量 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 连接池最大空闲 -->
		<property name="maxIdle" value="${maxIdle}" />
		<!-- 连接池最小空闲 -->
		<property name="minIdle" value="${minIdle}" />
		<!-- 获取连接最大等待时间 -->
		<property name="maxWait" value="${maxWait}" />

		<!-- <property name="poolPreparedStatements" value="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" value="33" /> -->

		<property name="validationQuery" value="${validationQuery}" />
		<property name="testOnBorrow" value="false" />
		<property name="testOnReturn" value="false" />
		<property name="testWhileIdle" value="true" />

		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />
		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />

		<!-- 打开removeAbandoned功能 -->
		<property name="removeAbandoned" value="true" />
		<!-- 1800秒，也就是30分钟 -->
		<property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" />
		<!-- 关闭abanded连接时输出错误日志 -->
		<property name="logAbandoned" value="true" />

		<!-- 监控数据库 -->
		<!-- <property name="filters" value="stat" /> -->
		<property name="filters" value="mergeStat" />
    </bean>
   <!-- 配置Jdbc模板  -->
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
    <constructor-arg ref="dataSource"></constructor-arg>
  </bean> 

    <bean id="baseDao" class="com.yw.dao.BaseDao" abstract="true">
    	 <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
    <bean id="userDAo" class="com.yw.dao.UserDao" parent="baseDao"/>  

    <!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<tx:advice id="transactionAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="append*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="modify*" propagation="REQUIRED" />
			<tx:method name="edit*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="remove*" propagation="REQUIRED" />
			<tx:method name="repair" propagation="REQUIRED" />
			<tx:method name="delAndRepair" propagation="REQUIRED" />
			<tx:method name="get*" propagation="SUPPORTS" />
			<tx:method name="find*" propagation="SUPPORTS" />
			<tx:method name="load*" propagation="SUPPORTS" />
			<tx:method name="search*" propagation="SUPPORTS" />
			<tx:method name="datagrid*" propagation="SUPPORTS"  />
			<tx:method name="*" propagation="SUPPORTS" />
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<aop:pointcut id="transactionPointcut" expression="execution(* com.yw.service..*(..))" />
		<aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
	</aop:config>
</beans>

　　

好了配置文件就这样可以了。
③ 接来下就是配置web.xml 的文件了：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>WebApp</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
   <!-- spring的配置 开始 -->
  <context-param>
  	<param-name>contextConfigLocation</param-name>
  	<param-value>classpath*:com/yw/conf/spring.xml</param-value>
  </context-param>
  <listener>
  	 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
   <!-- spring的配置 结束 -->

  <!-- springmvc的配置 开始  -->
  <servlet>
    <servlet-name>SpringMvc</servlet-name>
  	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
    	<param-name>contextConfigLocation</param-name>
    	<param-value>classpath*:com/yw/conf/springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
  	<servlet-name>SpringMvc</servlet-name>
  	<url-pattern>*.do</url-pattern>
  </servlet-mapping>
  <!-- springmvc的配置  结束 -->

  <!-- 字符的过滤器 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

　　

④ 创建包的结构了：

⑤创建一个base类dao了， 代码如下：

package com.yw.dao;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.sql.Types;
import java.util.List;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

/**
 * 有一个规则哦 ，所有model 的字段属性 id这个属性必须放在第一位，
 * 因为了后来数组拷贝用的
 * @author yw
 *
 * @param <T>
 * @param <Tb>
 */
public class BaseDao<T,Tb> {

	public static final String SQL_INSERT="insert";
	public static final String SQL_UPDATE="update";
	public static final String SQL_DELETE="delete";

    private Class<T> entityClass;
	private Class<Tb> pClass;
	protected NamedParameterJdbcTemplate namedParameterJdbcTemplate;
	protected JdbcTemplate jdbcTemplate;

	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	public BaseDao(){
		ParameterizedType type=(ParameterizedType) getClass().getGenericSuperclass();
		entityClass=(Class<T>) type.getActualTypeArguments()[0];
	    ParameterizedType  typep=(ParameterizedType) getClass().getGenericSuperclass();
	    pClass=(Class<Tb>) typep.getActualTypeArguments()[0];
	}
	//封装一下简单的组装sql语句，就是常用的哦
    public String SQl(String sqlFla){
		StringBuffer sb=new StringBuffer();
		//获取改bean所有的字段
		Field[] field=entityClass.getDeclaredFields();
		if(SQL_INSERT.equals(sqlFla)){
			sb.append("INSERT INTO ").append(entityClass.getSimpleName())
			.append(" (");
			for(int i=0;i<field.length;i++){
				field[i].setAccessible(true);//暴露反射
				sb.append(field[i].getName()).append(",");
			}
			sb.deleteCharAt(sb.length()-1);
			sb.append(" ) ").append("VALUES (");
			for(int i=0;i<field.length;i++){
				sb.append("?,");
			}
			sb.deleteCharAt(sb.length()-1);
			sb.append(" ) ");
		}
		else if(SQL_UPDATE.equals(sqlFla)){
			sb.append("UPDATE ").append(entityClass.getSimpleName()+" SET ");
			for(int i=0;i<field.length;i++){
				field[i].setAccessible(true);
				if(field[i].getName().equalsIgnoreCase("id")){
					continue;
				}
				sb.append(field[i].getName()).append(" = ").append("?,");
			}
			sb.deleteCharAt(sb.length()-1);
			sb.append(" WHERE id=?");
		}
		else if(SQL_DELETE.equals(sqlFla)){
			sb.append("DELETE FROM ").append(entityClass.getSimpleName());
			sb.append(" WHERE id=?");
		}
    	return sb.toString();
    }
    //设置值
    private Object[] setArgs(T entity,String sqlFla){
 		Field[] fields=entityClass.getDeclaredFields();
 		if(SQL_INSERT.equals(sqlFla)){
 			Object []obj=new Object[fields.length];
 			for (int i = 0; i < obj.length; i++) {
 				fields[i].setAccessible(true);
 				try {
					obj[i]=fields[i].get(entity);
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				}
			}
 			return obj;
 		}
 		else if(SQL_UPDATE.equals(sqlFla)){
 			Object []obj=new Object[fields.length];
 			int id=0;
 			for (int i = 0; i < obj.length; i++) {
 				fields[i].setAccessible(true);
 				try {
					obj[i]=fields[i].get(entity);
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
			}
 			Object []objArr=new Object[fields.length];
 		    System.arraycopy(obj, 1, objArr, 0, fields.length-1);
 		    objArr[obj.length - 1]=obj[0];
 		    return objArr;
 		}else if(SQL_DELETE.equals("delete")){
 			Object[] obj=new  Object[1];
 			fields[0].setAccessible(true);
 			try {
				obj[0]=fields[0].get(entity);
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
 			return obj;
 		}
 		return null;
 	}
    //设置值对应的类型
 	private  int [] setArgsTypes(T entity,String sqlFlag){
 		 Field[] fields = entityClass.getDeclaredFields();
         if (sqlFlag.equals(SQL_INSERT)) {
             int[] argTypes = new int[fields.length];
             try {
                 for (int i = 0; argTypes != null && i < argTypes.length; i++) {
                     fields[i].setAccessible(true); // 暴力反射
                     if (fields[i].get(entity).getClass().getName().equals("java.lang.String")) {
                         argTypes[i] = Types.VARCHAR;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Double")) {
                         argTypes[i] = Types.DECIMAL;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Integer")) {
                         argTypes[i] = Types.INTEGER;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.util.Date")) {
                         argTypes[i] = Types.DATE;
                     }  else if (fields[i].get(entity).getClass().getName().equals("java.sql.Timestamp")) {
                         argTypes[i] = Types.TIMESTAMP;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.math.BigDecimal")) {
                         argTypes[i] = Types.DECIMAL;
                     }
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
             return argTypes;
         } else if (sqlFlag.equals(SQL_UPDATE)) {
             int[] tempArgTypes = new int[fields.length];
             int[] argTypes = new int[fields.length];
             try {
                 for (int i = 0; tempArgTypes != null && i < tempArgTypes.length; i++) {
                     fields[i].setAccessible(true); // 暴力反射
                     if (fields[i].get(entity).getClass().getName().equals("java.lang.String")) {
                         tempArgTypes[i] = Types.VARCHAR;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Double")) {
                         tempArgTypes[i] = Types.DECIMAL;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Integer")) {
                         tempArgTypes[i] = Types.INTEGER;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.util.Date")) {
                         tempArgTypes[i] = Types.DATE;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.sql.Timestamp")) {
                     	tempArgTypes[i] = Types.TIMESTAMP;
                     } else if (fields[i].get(entity).getClass().getName().equals("java.math.BigDecimal")) {
                     	tempArgTypes[i] = Types.DECIMAL;
                     }
                 }
                 System.arraycopy(tempArgTypes, 1, argTypes, 0, tempArgTypes.length - 1); // 数组拷贝
                 argTypes[argTypes.length - 1] = tempArgTypes[0];  

             } catch (Exception e) {
                 e.printStackTrace();
             }
             return argTypes;  

         } else if (sqlFlag.equals(SQL_DELETE)) {
             int[] argTypes = new int[1]; // 长度是1
             try {
                 fields[0].setAccessible(true); // 暴力反射
                 if (fields[0].get(entity).getClass().getName().equals("java.lang.String")) {
                     argTypes[0] = Types.VARCHAR;
                 } else if (fields[0].get(entity).getClass().getName().equals("java.lang.Integer")) {
                     argTypes[0] = Types.INTEGER;
                 }  

             } catch (Exception e) {
                 e.printStackTrace();
             }
             return argTypes;
         }
         return null;
 	}

    public void save(T entity){
    	String sql=this.SQl(SQL_INSERT);
    	Object [] obj=this.setArgs(entity, SQL_INSERT);
    	System.out.println(sql);
    	for (int i = 0; i < obj.length; i++) {
    		System.out.println("--------------------");
			System.out.println(obj[i]);
			System.out.println("--------------------");
		}
    	int [] objTypes=this.setArgsTypes(entity, SQL_INSERT);
        jdbcTemplate.update(sql, obj,objTypes);
    }
    public void upate(T entity){
    	String sql=this.SQl(SQL_UPDATE);
    	Object [] obj=this.setArgs(entity, SQL_UPDATE);
    	int [] objTypes=this.setArgsTypes(entity, SQL_UPDATE);
        jdbcTemplate.update(sql, obj, objTypes);
    }
    public void delete(T entity){
    	String sql=this.SQl(SQL_DELETE);
    	Object [] obj=this.setArgs(entity, SQL_DELETE);
    	int [] objTypes=this.setArgsTypes(entity, SQL_DELETE);
        jdbcTemplate.update(sql, obj, objTypes);
    }
    public List<T> findAll(){
    	String sql="SELECT * FROM "+entityClass.getSimpleName();
    	RowMapper<T> rowMapper=BeanPropertyRowMapper.newInstance(entityClass);
    	return jdbcTemplate.query(sql, rowMapper);
    }
    public T findById(Serializable id){
    	String sql="SELECt * FROM  "+entityClass.getSimpleName()+"  where id=?";
    	RowMapper<T> rowMapper=BeanPropertyRowMapper.newInstance(entityClass);
    	if(jdbcTemplate.query(sql, rowMapper, id).size()>0)
    		return jdbcTemplate.query(sql, rowMapper, id).get(0);
		return null;
    }
}

　　⑥ 写一个Uerdao集成baseDao，代码如下

package com.yw.dao;

import com.yw.Dto.UserDto;
import com.yw.model.User;

public class UserDao extends BaseDao<User, UserDto> {
}

　　就是这样就行了，想增加一个sql语句就这样慢慢一个添加就的了

⑦ model和dto如下：

package com.yw.model;

public class User {
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", pass=" + pass + "]";
	}

	private Integer id;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getPass() {
		return pass;
	}

	public void setPass(String pass) {
		this.pass = pass;
	}
	private String name;
	private String pass;
}
/---------------------/
package com.yw.Dto;

public class UserDto {
private int id;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getPass() {
		return pass;
	}

	public void setPass(String pass) {
		this.pass = pass;
	}

	private String name;

	private String pass;
}

　　⑧ service层创建 一个Userservice,代码如下：

package com.yw.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.yw.dao.UserDao;
import com.yw.model.User;

@Service("userService")
public class UserService {
    @Autowired
	private UserDao  userDao;
    public void  save(User user){
    	userDao.save(user);
    }
    public void delete(User user){
    	userDao.delete(user);
    }
    public void update(User user){
    	userDao.upate(user);
    }
    public User findById(int id){
    	return userDao.findById(id);
    }
    public void findAll(){

    	List<User> user=userDao.findAll();
    	System.out.println(user);
    }
}

　　⑨ 就是Contrlloer层了 创建一个userController

package com.yw.Contrlloer;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.yw.model.User;
import com.yw.service.UserService;

@Controller
@RequestMapping("/test/controller")
public class UserController {
	@Autowired
	private UserService userService;

   @RequestMapping("/test.do")
	public void test(HttpServletRequest reServletRequest,HttpServletResponse response) throws IOException{
		 response.getWriter().println("23456789-");
		 //查询所有的用户
		 userService.findAll();
		 //查询id为2的用户
		 User user=userService.findById(2);
		 //增加一个用户
		 User user2=new User();
		 user2.setId(0); //增加数据的是数据库的id为在自增的，所以在这里就写死了
		 user2.setName("夏明");
		 user2.setPass("12345678");
		 userService.save(user2);
		 //删除一个用户
		 userService.delete(user);
		 //更新一个用户，更新之前最好是查询一次在更新
		 User user3=userService.findById(2);
		 user3.setName("GaVien");
		 userService.update(user3);

	}
}

　　

好了到这里算是真正完成了，直接跑起来O了，项目就这样就结束。
笔者说说在遇到问题和注意事项以及心得吧：
（1）笔者老是在配置spring配置出错的，老是报bean创建失败，出现这个问题 第一个可能是 扫描包可能没有扫到
第二可能是bean的配置的class的包的路径不对
第三可能是你的jdk编译有问题，如是：自己百度一下，更换一下jdk吧
第四可能是你没有添加bean吧
（2）创建model的时候有id的必须在所有字段的属性前面，为后来的baseDao的数据拷贝方便呢
（3）经过笔者的测试 ，自己的写反射运行和数据库响应时间并没有比mybatis和hibernate慢甚至还快呢呢，而且自己写的反射所有sql语句都可以自己去控制，没有任何多余的数据呢，
（4）对于宇宙无敌的spring框架不熟，那你就只能自己去补了，反射也是咯 哈哈

最后项目下载路径 http://pan.baidu.com/s/1c2mMHiS

时间： 2024-08-02 19:55:03

利用反射搭建项目的dao层，从此可以告别被人的dao层框架了（spring+反射）的相关文章

利用Jersey搭建Rest的Web服务

传统模式下,一般利用servlet+jsp来完成前后台的交互,但是现在随着技术的进步,利用rest总线作为数据访问一种方式成为一种流行.本片博文主要利用Jersey搭建rest服务,并且利用mybatis作为数据库访问方式构建一个从前台到后台交互并且实现数据持久化的一个完整架构. 1,首先构建一个maven web项目,项目结构如下: 其中pom.xml文件中的dependency如下: <dependencies> <!--jersey --> <dependency>

java反射+java泛型，封装BaseDaoUtil类。供应多个不同Dao使用

当项目是ssh框架时,每一个Action会对应一个Service和一个Dao.但是所有的Ation对应的Dao中的方法是相同的,只是要查的表不一样.由于封装的思想,为了提高代码的重用性.可以使用java中的泛型+反射去实现最终的封装,将所有的Dao层的共同部分写一个BaseDaoUtil.而所有的Dao都继承这个类. 思路: ----->(1)反射+泛型 ----->(2)当生成子类对象(UserDao),调用空构造时(new UserDao()),子类的空构造会默认调用父类的空构造器(new

利用keras搭建CNN进行mnist数据集分类

当接触深度学习算法的时候,大家都很想自己亲自实践一下这个算法,但是一想到那些复杂的程序,又感觉心里面很累啊,又要学诸如tensorflow.theano这些框架.那么,有没有什么好东西能够帮助我们快速搭建这个算法呢?当然是有咯!,现如今真不缺少造轮子的大神,so,我强烈向大家推荐keras,Keras是一个高层神经网络API,Keras由纯Python编写而成并基Tensorflow或Theano.Keras为支持快速实验而生,能够把你的idea迅速转换为结果. 具体keras的安装与使用,请参

利用nexus搭建maven私有仓库

闲的没事自己搭建了一个私有仓库,把操作记录下载留待以后翻阅. 1.安装nexus环境. 首先去官网下载nexus oss的zip包http://www.sonatype.org/nexus/,这个是免费使用的. 下载完成之后解压zip包.然后cmd命令进入nexus目录下的bin目录,首次使用需要先安装nexus,执行nexus.bat install: 提示安装成功,然后继续输入命令nexus.bat start:稍等一下就会看到nexus启动成功信息.启动完成输入地址http://local

Maven创建并管理Web项目（上传Web项目的API的JAR到Nexus 私服上）

目录 1.简介 2.安装Eclipse Maven插件 3.用Eclipse创建Maven Web项目 4.配置settings.xml 文件并下载项目依赖的JAR,并上传Web项目的api的JAR到Nexus 私服 1.简介 Maven.Nexus 私服的安装和配置和Maven的优点在Maven和 Sonatype Nexus私服的安装.配置及使用入门已经有介绍了,这里就不在介绍了,今天我们要介绍Maven创建并管理Web项目,方便我们项目的开发和管理. 2.安装Eclipse Maven插件

利用Jenkins搭建iOS项目可持续化集成环境（ Continuous Integration 简称CI）

前言 关于Jenkins的相关博客网上有很多,这里不再重复说.新进公司要搭建该环境,我也是参考了如下博文:http://www.jianshu.com/p/41ecb06ae95f 文中说的很详细也不再细说.当然在实际搭建中也遇到了不少的坑,所以特写此博客以作补充. 1. 初始密码获取 命令行:cd /Users/Shared/Jenkins/Home/ 到当前目录,修改/secrets/目录权限后使用vim编辑器打开initialAdminPassword文件就可以复制里面的密码了. 2. 构

09_Android中ContentProvider和Sqllite混合操作，一个项目调用另外一个项目的ContentProvider

1.  编写ContentPrivider提供者的Android应用 清单文件 <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.itheima28.sqlitedemo" android:versionCode=&qu

Kafka1 利用虚拟机搭建自己的Kafka集群

前言:       上周末自己学习了一下Kafka,参考网上的文章,学习过程中还是比较顺利的,遇到的一些问题最终也都解决了,现在将学习的过程记录与此,供以后自己查阅,如果能帮助到其他人,自然是更好的. ===============================================================长长的分割线==================================================================== 正文: 关于Kafka

ZooKeeper1 利用虚拟机搭建自己的ZooKeeper集群

前言:       前段时间自己参考网上的文章,梳理了一下基于分布式环境部署的业务系统在解决数据一致性问题上的方案,其中有一个方案是使用ZooKeeper,加之在大数据处理中,ZooKeeper确实起到协调服务的作用,所以利用周末休息时间,自己在虚拟机上简单搭建了一个ZooKeeper集群,学习了解一下. ===============================================================长长的分割线===========================