`

Spring SpringMvc JdbcTemplate NamedParameterJdbcTemplate

 
阅读更多

最近进入新的公司，别人数据库层直接使用Spring的JdbcTemplate和NamedParameterJdbcTemplate，之前mybatis，hibernate都用，写了个demo用了一下感觉这个也比较好用

 

1.环境搭建： Spring4.1.6+Springmvc+mysql5.6+eclipse4.2

项目的创建使用eclipse就不说了

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.share</groupId>
  <artifactId>jdbc</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <properties>
		<!-- spring的版本号 -->
		<org.springframework.version>4.1.6.RELEASE</org.springframework.version>
		<!-- mybatis版本号 
		<mybatis.version>3.3.0</mybatis.version>-->
  </properties>
  
  <dependencies>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-beans</artifactId>
  		<version>${org.springframework.version}</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-core</artifactId>
  		<version>${org.springframework.version}</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-web</artifactId>
  		<version>${org.springframework.version}</version>
  	</dependency>
  	<dependency>  
         <groupId>org.springframework</groupId>  
         <artifactId>spring-oxm</artifactId>  
         <version>${org.springframework.version}</version>  
     </dependency>  
     <dependency>  
         <groupId>org.springframework</groupId>  
         <artifactId>spring-tx</artifactId>  
         <version>${org.springframework.version}</version>  
     </dependency>  

     <dependency>  
         <groupId>org.springframework</groupId>  
         <artifactId>spring-jdbc</artifactId>  
         <version>${org.springframework.version}</version>  
     </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context-support</artifactId>  
            <version>${org.springframework.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-test</artifactId>  
            <version>${org.springframework.version}</version>  
        </dependency>  
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-context</artifactId>
        	<version>${org.springframework.version}</version>
        </dependency>
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-expression</artifactId>
        	<version>${org.springframework.version}</version>
        </dependency>
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-orm</artifactId>
        	<version>${org.springframework.version}</version>
        </dependency>
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-webmvc</artifactId>
        	<version>${org.springframework.version}</version>
        </dependency>
        
        <!-- 导入Mysql数据库链接jar包 -->  
        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.35</version>  
        </dependency>
        <dependency>
        	<groupId>com.mchange</groupId>
        	<artifactId>c3p0</artifactId>
        	<version>0.9.5-pre10</version>
        </dependency>
            <!-- JSTL标签类 -->  
        <dependency>  
            <groupId>jstl</groupId>  
            <artifactId>jstl</artifactId>  
            <version>1.2</version>  
        </dependency>  
        <!-- 日志文件管理包 -->  
        <!-- log start -->  
        <dependency>  
            <groupId>log4j</groupId>  
            <artifactId>log4j</artifactId>  
            <version>1.2.17</version>
        </dependency>  
          
          
        <!-- 格式化对象，方便输出日志 -->  
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>fastjson</artifactId>  
            <version>1.1.41</version>  
        </dependency>  
  
  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-api</artifactId>  
            <version>1.7.12</version>  
        </dependency>  
  
        <!-- log end -->  
        <!-- 映入JSON -->  
        <dependency>  
            <groupId>org.codehaus.jackson</groupId>  
            <artifactId>jackson-mapper-asl</artifactId>  
            <version>1.9.13</version>  
        </dependency>  
        <!-- 上传组件包 -->  
        <dependency>  
            <groupId>commons-fileupload</groupId>  
            <artifactId>commons-fileupload</artifactId>  
            <version>1.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-io</groupId>  
            <artifactId>commons-io</artifactId>  
            <version>2.4</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-codec</groupId>  
            <artifactId>commons-codec</artifactId>  
            <version>1.9</version>  
        </dependency>
        <dependency>
        	<groupId>org.apache.tomcat</groupId>
        	<artifactId>tomcat-servlet-api</artifactId>
        	<version>8.0.23</version>
        </dependency>
        
        <dependency>
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-support</artifactId>
        	<version>2.0.8</version>
        </dependency>
        <dependency>
        	<groupId>org.apache.commons</groupId>
        	<artifactId>commons-lang3</artifactId>
        	<version>3.4</version>
        </dependency>
  </dependencies>
</project>

 2.配置文件的创建

jdbc.properties(数据库配置文件)

 

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/learn?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

 beans.xml(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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
			http://www.springframework.org/schema/beans/spring-beans.xsd 
			http://www.springframework.org/schema/mvc 
			http://www.springframework.org/schema/mvc/spring-mvc.xsd 
			http://www.springframework.org/schema/context 
			http://www.springframework.org/schema/context/spring-context.xsd 
			http://www.springframework.org/schema/aop 
			http://www.springframework.org/schema/aop/spring-aop.xsd 
			http://www.springframework.org/schema/tx 
			http://www.springframework.org/schema/tx/spring-tx.xsd ">
		
	<!-- 支持注解 -->
	<context:annotation-config/>
			 
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.share.*"/>
        
    <!--数据库配置:配置jdbc.properties  -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 3、配置dataSource数据源c3p0 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClassName}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
		
		<!-- <property name="maxPoolSize" value="${c3p0.pool.maxPoolSize}"/>
		<property name="minPoolSize" value="${c3p0.pool.minPoolSize}"/>
		<property name="initialPoolSize" value="${c3p0.pool.initialPoolSize}"/>
		<property name="acquireIncrement" value="${c3p0.pool.acquireIncrement}"/> -->
	</bean>
	
	<!-- JDBCTemplate注入 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name = "dataSource" ref="dataSource"/>  
	</bean>
	<!-- namedParameterJdbcTemplate注入，此处在构造器中 -->
	<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<constructor-arg ref="dataSource"/>
	</bean>    	
</beans>

 springmvc.xml（springmvc配置文件）

 

<?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:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd 
						http://www.springframework.org/schema/mvc 
						http://www.springframework.org/schema/mvc/spring-mvc.xsd 
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context.xsd 
						http://www.springframework.org/schema/aop 
						http://www.springframework.org/schema/aop/spring-aop.xsd 
						http://www.springframework.org/schema/tx 
						http://www.springframework.org/schema/tx/spring-tx.xsd ">
				
		<!-- 支持注解驱动 -->
		<mvc:annotation-driven/>	
		
		<!-- 组件扫描的包 -->	
		<context:component-scan base-package="com.share.*"/>
		<!-- 静态资源目录 -->
		<mvc:resources mapping="/js/**" location="/js/" />
		<mvc:resources mapping="/images/**" location="/images/" />
		<mvc:resources mapping="/css/**" location="/css/" />
		<mvc:resources mapping="/common/**" location="/common/" />
		
		
		<!-- 配置视图解析器 -->
		<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		
			<!-- 通过setter方法注入前缀 -->
			<property name="prefix" value="/WEB-INF/pages/"/>
			<!-- 通过setter方法注入后缀 -->				
			<property name="suffix" value=".jsp"></property>
		</bean>

		<!-- 文件上传配置 -->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="20971520"/><!--byte为单位，最高上传20M-->
        <property name="defaultEncoding" value="UTF-8"/>
        <property name="resolveLazily" value="true"/>
    </bean>
    
    <!-- 配置文件上传异常，文件超出上传限制时抛出异常信息，跳到异常页面 -->
    <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    	<property name="exceptionMappings">
    		<props>
    			<!-- 遇到MaxUploadSizeExceededException异常时，自动跳转到/WEB-INF/jsp/error_fileupload.jsp页面 -->
    			  <prop  key="org.springframework.web.multipart.MaxUploadSizeExceededException">error_fileupload</prop>    
    		</props>
    	</property>
    </bean>
    	
</beans>

 log4j.xml

 

log4j.rootLogger=INFO,stdout,file

log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout.ConversionPattern=%-d{yyyy-MM-dd HH\:mm\:ss,SSS} [%c]-[%p] %m%n 

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender 
#log4j.appender.file.File=${spring_springmvc_jpa.root}/shirodemo.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout 
log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n

log4j.logger.org.hibernate.tool.hbm2ddl=info

 实体类：User.java

 

public class User implements Serializable {

		private static final long serialVersionUID = 1L;

		private long id;//用户id
		private String username;//用户名
		private int age;//用户年龄
		private Date birthday;//用户生日

		public long getId() {
			return id;
		}

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

		public User() {
			super();
		}

		public String getUsername() {
			return username;
		}

		public void setUsername(String username) {
			this.username = username;
		}

		public int getAge() {
			return age;
		}

		public void setAge(int age) {
			this.age = age;
		}

		public Date getBirthday() {
			return birthday;
		}

		public void setBirthday(Date birthday) {
			this.birthday = birthday;
		}

		public User(String username, int age, Date birthday) {
			super();
			this.username = username;
			this.age = age;
			this.birthday = birthday;
		}

		@Override
		public String toString() {
			return "User [username=" + username + ", age=" + age + ", birthday="
					+ birthday + "]";
		}

}

 dao层：BaseDao.java

 

package com.share.dao;

/**
 * 基本dao
 * @author share
 *
 */
@Repository
public class BaseDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;
	@Autowired
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
	
	/**
	 * 查询所有用户
	 * @param sql
	 * @return
	 */
	public List<Map<String, Object>> queryAll(String sql) {
		System.out.println(jdbcTemplate + "&&" + namedParameterJdbcTemplate);
		return jdbcTemplate.queryForList(sql);
	}
	
	/**
	 * 添加用户
	 * @param user
	 * @return
	 */
	public int addUser(User user) {
		StringBuffer sqlKey = new StringBuffer("insert into user (");
		StringBuffer sqlValue = new StringBuffer(" values ( ");
		Map<String, Object> paramMap = new HashMap<String, Object>();
		if(StringUtils.isNotBlank(user.getUsername())) {
			sqlKey.append(" username, ");
			sqlValue.append(" :username, ");
			paramMap.put("username", user.getUsername());
		}
		if(StringUtils.isNotBlank(String.valueOf(user.getAge()))) {
			sqlKey.append(" age");
			sqlValue.append(" :age ");
			paramMap.put("age", user.getAge());
		}
		sqlKey.append(" ) ");
		sqlValue.append(" ) ");
		sqlKey.append(sqlValue);
		return namedParameterJdbcTemplate.update(sqlKey.toString(), paramMap);
		
	}
	
	/**
	 * 查找用户
	 */
	public User findUserByName(String username) {
		String sql = "select * from user where username = ?";
		User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), username);//此处需要在实现RowMapper接口了
		System.err.println(user.getUsername() + "::" + user.getAge());
		Map<String, Object> queryForMap = jdbcTemplate.queryForMap(sql, username);
		System.out.println("=========");
		for (Map.Entry<String, Object> map : queryForMap.entrySet()) {
			System.out.println(map.getKey() + "**" + map.getValue());
		}
		return user;
		
	}
}

 service层BaseService.java

 

/**
 * @author caifan
 *
 * 2015年6月20日
 */
@Service
public class BaseService {
	@Autowired
	private BaseDao baseDao;
	
	/**
	 * 基本service
	 * @return
	 */
	public List<Map<String, Object>> findAllUser() {
		String sql = "select * from user order by age desc";
		List<Map<String,Object>> queryForList = baseDao.queryAll(sql);
		for (Map<String, Object> maps : queryForList) {
			System.out.println( "------------");
			for (Map.Entry<String, Object> map : maps.entrySet()) {
				System.out.println(map.getKey() + ":" + map.getValue());
			}
			System.out.println( "------------");
		}
		return queryForList;
	}
	
	/**
	 * 添加用户
	 * @param user
	 * @return
	 */
	public int addUser(User user) {
		return baseDao.addUser(user);
	}
	
	public User findByName(String username) {
		return baseDao.findUserByName(username);
		
	}
	
}

控制层： UserController.java

 

/**
 * 
 */
package com.share.controller;

import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

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

import com.share.domain.User;
import com.share.service.BaseService;

/**
 * @author caifan
 *
 * 2015年6月20日
 */
@Controller
public class UserController {
	@Autowired
	private BaseService baseService;
	
	@RequestMapping(value="/alluser") 
	public String findAllUser(HttpServletRequest request) {
		List<Map<String, Object>> userList = baseService.findAllUser();
		request.setAttribute("userList", userList);
		return "alluser";
	}
	
	@RequestMapping(value="/adduser") 
	public String addUser(HttpServletRequest request) {
		User user = new User();
		user.setUsername("tom");
		user.setAge(22);
		int userResult = baseService.addUser(user);
		System.out.println(userResult);
		request.setAttribute("user", user);
		return "adduser";
	}
	
	@RequestMapping(value="/finduser")
	public String findUser(HttpServletRequest request) {
		String username = "tom";
		User user = baseService.findByName(username);
		request.setAttribute("user", user);
		return "findUser";
	}
}

 附件中的jsp仅用于测试

 

分享到：
| jsp foreach中的索引varstatus与if 空判 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springmvc-jdbcTemplate

    namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate.getDataSource()); //初始化pagingSqlBuilder pagingSqlBuilder = new PagingSqlBuilder(((ComboPooledDataSource) ...

    spring+springMvc+jdbc 简易框架整合

    在Spring整合中，JDBC通常通过Spring的数据访问抽象层来使用，例如JdbcTemplate或NamedParameterJdbcTemplate，它们简化了SQL查询的编写和执行，同时提供了事务管理和异常处理。在本项目中，可能有一个配置文件（如`...

    Spring mvc、 Spring、 Spring jdbc 整合 demo

    - 在数据访问层中，使用Spring JDBC的JdbcTemplate或NamedParameterJdbcTemplate来执行SQL语句。 - 在Service层，通过AOP实现事务管理，确保数据一致性。 - 编写Controller，接收并处理HTTP请求，调用Service层...

    SpringMVC+Spring+SpringJDBC

    **SpringMVC、Spring与SpringJDBC整合详解** 在Java Web开发中，Spring框架因其强大的功能和灵活性而被广泛使用。SpringMVC、Spring和SpringJDBC是Spring框架的三个重要组成部分，它们协同工作，提供了从用户接口到...

    SpringMVC + Spring + SpringJDBC整合demo

    通过SpringJDBC，开发者无需手动创建数据库连接、编译SQL语句、处理结果集，而是可以通过Template类如JdbcTemplate或NamedParameterJdbcTemplate来完成这些任务，大大降低了代码的复杂性和出错的可能性。SpringJDBC...

    spring+springMVC+mysql+JSON的jar包整合

    Spring框架也提供了对JDBC的高级封装，如JdbcTemplate和NamedParameterJdbcTemplate，简化了数据库操作。 JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和...

    spring+springmvc+springjdbc+redis

    例如，使用JdbcTemplate和NamedParameterJdbcTemplate可以方便地执行SQL查询和更新操作，同时保持代码的整洁。 Redis是一个开源的、高性能的键值存储系统，常用于缓存、会话管理、消息队列等场景。它支持多种数据...

    spring3+springMVC3+springJDBC3+jQuery easyui的运行环境

    通过Spring JDBC，开发者可以使用模板方法（如JdbcTemplate或NamedParameterJdbcTemplate）来执行SQL语句，这些模板类会自动处理资源的打开和关闭，以及异常处理，使代码更加简洁且易于测试。此外，Spring JDBC还...

    java开发之SpringMVC + Spring + SpringJDBC整合.zip

    SpringJDBC通过JdbcTemplate或NamedParameterJdbcTemplate提供了一套模板方法，使得SQL查询和参数绑定更加直观和安全。此外，SpringJDBC还支持事务管理，可以方便地进行回滚和提交操作，确保数据一致性。 在整合这...

    开源框架面试题系列：Spring+SpringMVC+MyBatis-08.rar

    - **Spring JDBC与数据访问**：提供模板类简化数据库操作，如JdbcTemplate、NamedParameterJdbcTemplate等。 - **Spring MVC**：Spring的Web层组件，处理HTTP请求，实现MVC设计模式。 2. **SpringMVC框架** - **...

    springMVC-JDBC例子

    在Spring中整合JDBC，我们可以利用Spring的JdbcTemplate或NamedParameterJdbcTemplate类，它们提供了更安全、更易于使用的数据库操作接口。例如，我们可以通过以下步骤实现： 1. 配置数据库连接：在Spring的配置...

    maven+spring+jdbc+mvc项目整合

    在Spring项目中，JDBC通常通过Spring的JdbcTemplate或NamedParameterJdbcTemplate进行封装，以减少代码量和提高可维护性。 **MVC** 模式是一种软件设计模式，用于分离应用程序的数据逻辑、用户界面和业务逻辑。在...

    Spring mvc + Spring + Spring jdbc 整合 demo

    7. **数据库配置**：在applicationContext.xml中，我们需要配置数据源（DataSource）以及JdbcTemplate或NamedParameterJdbcTemplate的bean，以便Spring能够连接到数据库并执行SQL语句。 8. **事务管理**：如果项目...

    SpringMVC+Oracle数据源demo项目完整代码

    Spring的JdbcTemplate或NamedParameterJdbcTemplate可以简化数据库操作，提供SQL执行的便利性。 此外，为了确保数据的一致性，可能还会涉及到事务控制。在Spring中，你可以使用@Transactional注解在方法级别声明...

    spring开发相关jar包（json，springweb，springmvc，jdbc等）

    Spring提供了JdbcTemplate和NamedParameterJdbcTemplate等工具类，简化了DAO层的实现。 6. **JDBC (Java Database Connectivity)**：JDBC是Java语言连接数据库的标准API。Spring JDBC模块提供了一种高级的抽象层，...

    jquery+springmvc+springjdbc+sprngquartz整合java项目

    3. **配置SpringJDBC**：创建DataSource，定义JdbcTemplate或NamedParameterJdbcTemplate，编写DAO接口和实现。 4. **设置SpringQuartz**：配置Scheduler，定义Job和Trigger，将它们加入到Scheduler中。 5. **...

    SpringMVC+Mysql实例详解

    SpringMVC是Spring框架的一部分，专门用于构建Web应用程序。它是一个模型-视图-控制器（MVC）架构的实现，提供了处理HTTP请求、业务逻辑控制和数据展示的能力。在这个实例详解中，我们将深入理解SpringMVC的核心概念...

    springMVC+springJDBC

    通过使用 JdbcTemplate 或 NamedParameterJdbcTemplate，你可以方便地执行 SQL 查询和更新语句，而无需关心底层的数据库连接细节。Spring JDBC 还支持数据源配置、事务管理，以及异常转换，使得数据库操作更加健壮和...

Magicbox
Global site tag (gtag.js) - Google Analytics