Spring Hibernate CRUD

最新推荐文章于 2023-10-11 01:10:28 发布
原创 最新推荐文章于 2023-10-11 01:10:28 发布 · 116 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #数据库

本文介绍了一个使用Spring框架和Hibernate ORM技术实现的简单应用案例。该案例涵盖了Maven依赖配置、数据库表结构定义、日志配置、Spring配置文件、实体类定义、DAO层接口及其实现类、以及单元测试等内容。

1.Maven Dependency

<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>org.fool.springjdbc</groupId>
	<artifactId>springhibernate</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springhibernate</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring-version>3.2.2.RELEASE</spring-version>
		<aspectj-version>1.7.2</aspectj-version>
		<commons-dbcp-version>1.4</commons-dbcp-version>
		<hibernate-version>4.1.11.Final</hibernate-version>
		<junit-version>4.11</junit-version>
		<mysql-connector-version>5.1.24</mysql-connector-version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${aspectj-version}</version>
		</dependency>

		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>${commons-dbcp-version}</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate-version}</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit-version}</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql-connector-version}</version>
		</dependency>
	</dependencies>
</project>

 

2.Project Directory


 

 

3.src/main/resources

schema.sql

drop table if exists t_user ;
drop table if exists t_group ;

create table t_group
(
	gid integer not null auto_increment,
	name varchar(20) not null,
	constraint group_gid_pk primary key(gid)
);

create table t_user
(
	uid integer not null auto_increment,
	username varchar(20) not null,
	password varchar(20) not null,
	nickname varchar(20) not null,
	gid integer,
	constraint user_uid_pk primary key(uid),
	constraint group_user_gid_fk foreign key(gid) references t_group(gid)
);

 

log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
#log4j.logger.org.hibernate.tool.hbm2ddl=debug

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
#log4j.logger.org.hibernate.cache=debug

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

 

jdbc.properties

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8 
jdbc.username = root
jdbc.password = 123456

 

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	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-3.2.xsd  
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context-3.2.xsd  
        http://www.springframework.org/schema/tx   
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
        http://www.springframework.org/schema/aop  
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

	<context:annotation-config />

	<context:component-scan base-package="org.fool.springhibernate" />

	<context:property-placeholder location="classpath:jdbc.properties" />

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<!-- 配置连接池的初始值 -->
		<property name="initialSize" value="1" />
		<!-- 连接池的最大值 -->
		<!-- <property name="maxActive" value="500"/> -->
		<!-- 最大空闲时，当经过一个高峰之后，连接池可以将一些用不到的连接释放，一直减少到maxIdle为止 -->
		<!-- <property name="maxIdle" value="2"/> -->
		<!-- 当最小空闲时，当连接少于minIdle时会自动去申请一些连接 -->
		<property name="minIdle" value="1" />
		<property name="maxActive" value="100" />
		<property name="maxIdle" value="20" />
		<property name="maxWait" value="1000" />
	</bean>

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan" value="org.fool.springhibernate.model" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQL5Dialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.current_session_context_class">
					org.springframework.orm.hibernate4.SpringSessionContext
				</prop>
			</props>
		</property>
	</bean>

	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- 配置AOP，Spring是通过AOP来进行事务管理的 -->
	<aop:config>
		<!-- 设置pointCut表示哪些方法要加入事务处理 -->
		<aop:pointcut id="allMethods"
			expression="execution(* org.fool.springhibernate.dao.*.*(..))" />
		<!-- 通过advisor来确定具体要加入事务控制的方法 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods" />
	</aop:config>
	<!-- 配置哪些方法要加入事务控制 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 让所有的方法都加入事务管理，为了提高效率，可以把一些查询之类的方法设置为只读的事务 -->
			<tx:method name="*" propagation="REQUIRED" read-only="true" />
			<!-- 以下方法都是可能设计修改的方法，就无法设置为只读 -->
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="del*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="save*" propagation="REQUIRED" />
		</tx:attributes>
	</tx:advice>

</beans>

 

4.src/main/java

Group.java

package org.fool.springhibernate.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_group")
public class Group
{
	private int id;
	private String name;

	@Id
	@GeneratedValue
	@Column(name ="gid")
	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;
	}

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

}

 User.java

package org.fool.springhibernate.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "t_user")
public class User
{
	private int id;
	private String username;
	private String password;
	private String nickname;
	private Group group;

	public User()
	{
	}

	public User(String username, String password, String nickname)
	{
		this.username = username;
		this.password = password;
		this.nickname = nickname;
	}

	@ManyToOne
	@JoinColumn(name = "gid")
	public Group getGroup()
	{
		return group;
	}

	public void setGroup(Group group)
	{
		this.group = group;
	}

	@Id
	@GeneratedValue
	@Column(name = "uid")
	public int getId()
	{
		return id;
	}

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

	public String getUsername()
	{
		return username;
	}

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

	public String getPassword()
	{
		return password;
	}

	public void setPassword(String password)
	{
		this.password = password;
	}

	public String getNickname()
	{
		return nickname;
	}

	public void setNickname(String nickname)
	{
		this.nickname = nickname;
	}

	@Override
	public String toString()
	{
		return "User [id=" + id + ", username=" + username + ", password="
				+ password + ", nickname=" + nickname + ", group=" + group
				+ "]";
	}

}

 

BaseDAO.java

package org.fool.springhibernate.dao;

import java.util.List;

public interface BaseDAO<T>
{
	public void add(T t);

	public void delete(int id);

	public void update(T t);

	public T load(int id);

	public List<T> list(String hql, Object[] args);

	public List<T> list(String hql, Object arg);

	public List<T> list(String hql);

}

 

BaseDAOImpl.java

package org.fool.springhibernate.dao;

import java.lang.reflect.ParameterizedType;
import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class BaseDAOImpl<T> implements BaseDAO<T>
{
	@Resource
	private SessionFactory sessionFactory;

	/**
	 * 创建一个Class的对象来获取泛型的class
	 */
	private Class<T> clz;

	@SuppressWarnings("unchecked")
	public Class<T> getClz()
	{
		if (clz == null)
		{
			// 获取泛型的Class对象
			clz = ((Class<T>) (((ParameterizedType) (this.getClass()
					.getGenericSuperclass())).getActualTypeArguments()[0]));
		}

		return clz;
	}

	protected Session getSession()
	{
		return sessionFactory.getCurrentSession();
	}

	@Override
	public void add(T t)
	{
		this.getSession().save(t);
	}

	@Override
	public void delete(int id)
	{
		this.getSession().delete(this.load(id));
	}

	@Override
	public void update(T t)
	{
		this.getSession().update(t);
	}

	@SuppressWarnings("unchecked")
	@Override
	public T load(int id)
	{
		return (T) this.getSession().get(getClz(), id);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<T> list(String hql, Object[] args)
	{
		Query query = this.getSession().createQuery(hql);

		if (args != null)
		{
			for (int i = 0; i < args.length; i++)
			{
				query.setParameter(i, args[i]);
			}
		}

		return query.list();
	}

	@Override
	public List<T> list(String hql, Object arg)
	{
		return this.list(hql, new Object[] { arg });
	}

	@Override
	public List<T> list(String hql)
	{
		return this.list(hql, null);
	}
}

 

GroupDAO.java

package org.fool.springhibernate.dao;

import org.fool.springhibernate.model.Group;

public interface GroupDAO extends BaseDAO<Group>
{
	
}

 

GroupDAOImpl.java

package org.fool.springhibernate.dao;

import org.fool.springhibernate.model.Group;
import org.springframework.stereotype.Repository;

@Repository("groupDAO")
public class GroupDAOImpl extends BaseDAOImpl<Group> implements GroupDAO
{

}

 

UserDAO.java

package org.fool.springhibernate.dao;

import org.fool.springhibernate.model.User;

public interface UserDAO extends BaseDAO<User>
{
	/**
	 * 添加用户
	 */
	public void add(User user, int gid);

	/**
	 * 获取某个组中的用户数量
	 */
	public long getGroupUserCount(int gid);

	/**
	 * 删除组中的用户
	 */
	public void deleteByGroup(int gid);
}

 

UserDAOImpl.java

package org.fool.springhibernate.dao;

import javax.annotation.Resource;

import org.fool.springhibernate.model.Group;
import org.fool.springhibernate.model.User;
import org.springframework.stereotype.Repository;

@Repository("userDAO")
public class UserDAOImpl extends BaseDAOImpl<User> implements UserDAO
{
	@Resource
	private GroupDAO groupDAO;

	@Override
	public void add(User user, int gid)
	{
		Group group = groupDAO.load(gid);
		user.setGroup(group);

		this.getSession().save(user);
	}

	@Override
	public long getGroupUserCount(int gid)
	{
		String hql = "select count(*) from User where group.id=?";

		long count = (Long) this.getSession().createQuery(hql)
				.setParameter(0, gid).uniqueResult();

		// String sql = "select count(*) from t_user where gid=?";
		//
		// long count = (long) this.getSession().createSQLQuery(sql).setParameter(0, gid)
		//		.uniqueResult();

		return count;
	}

	@Override
	public void deleteByGroup(int gid)
	{
		String hql = "delete User u where u.group.id=?";

		this.getSession().createQuery(hql).setParameter(0, gid).executeUpdate();
	}

}

 

5.src/test/java

TestSpringHibernate.java

package org.fool.springhibernate.test;

import java.util.List;

import javax.annotation.Resource;

import org.fool.springhibernate.dao.GroupDAO;
import org.fool.springhibernate.dao.UserDAO;
import org.fool.springhibernate.model.Group;
import org.fool.springhibernate.model.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:beans.xml")
public class TestSpringHibernate
{
	@Resource(name = "userDAO")
	private UserDAO userDAO;

	@Resource(name = "groupDAO")
	private GroupDAO groupDAO;

	@Test
	public void testAdd()
	{
		Group group = new Group();
		group.setName("Test");
		groupDAO.add(group);

		User user = new User("SpringHibernate", "456789", "SH");
		userDAO.add(user, 10);
	}

	@Test
	public void testLoad()
	{
		Group group = groupDAO.load(3);
		System.out.println(group);
	}

	@Test
	public void testUpdate()
	{
		User user = userDAO.load(5);
		System.out.println(user);

		user.setNickname("HS");
		userDAO.update(user);
		System.out.println(user);
	}

	@Test
	public void testDelete()
	{
		userDAO.delete(3);
	}

	@Test
	public void testList()
	{
		String hql1 = "from User u where u.username = ?";
		String hql2 = "from Group";

		List<User> users = userDAO.list(hql1, new Object[] { "SpringHibernate" });
		List<Group> groups = groupDAO.list(hql2);

		for (User user : users)
		{
			System.out.println(user);
		}
		
		for (Group group : groups)
		{
			System.out.println(group);
		}
	}

	@Test
	public void testGetGroupUserCount()
	{
		Assert.assertEquals(6, userDAO.getGroupUserCount(10));
	}

	@Test
	public void testDeleteByGroup()
	{
		userDAO.deleteByGroup(10);
		Assert.assertEquals(0, userDAO.getGroupUserCount(10));
	}

}

 

 

 

 

 

 

Spring-MVC-Hibernate-CRUD
05-26
Spring MVC Hibernate MySQL 数据库“打印机之家” 一个小型的Web应用程序，用于使用数据库表进行Crud操作。 开发者 艾尔·库尔皮金（IHOR KULPEKIN） 技术领域 编程语言： Java； 互联网技术： HTML，CSS，JavaScript； 数据库： MySQL； Web： JSP； Servlet容器： Tomcat； 集成开发环境： IntelliJ IDEA； 框架： Spring，Hibernate，Junit，Mockito；
spring+hibernate CRUD 简单示例
08-30
集成 spring hibernate 的例子，这个例子在 tomcat6.0 MyEclipse6.0 下测试通过，里面导入的包都是MyEclipse自带的
[spring] spring jpa - hibernate CRUD
GoldenaArcher的博客
10-11 249
上篇笔记 [spring] spring jpa - hibernate 名词解释&配置 过了一些概念性的东西，本篇笔记就把实操过一遍这里通过 EntityManager（Spring 通过 DI 注入的依赖）和 DAO（设计模式）实现，大体实现结构为生成一个 DAO interface，再生成一个 DAOImpl 的类去实现代码：DAO DAOImpl这里首先要定义这是一个 类型的 bean，随后通过 DI 获取 Spring 自动生成的 entityManager： 整体来说使用 JPA 进行
Spring和hibernate集成写API进行CRUD操作
承接app开发，旅游电商网站设计
10-13 446
配置maven引入spring 4和hibernate 4的依赖包： - spring-core - spring-webmvc - spring-orm - aspectjrt - hibernate-core - hibernate-entitymanager 另外引入必要的maven-plugin和junit用来跑unit test： - maven-compile
SpringTeamCRUD:Spring+HibernateCRUD
04-28
《Spring+Hibernate CRUD操作详解》 在IT领域，Spring和Hibernate是两个非常重要的框架，它们在企业级应用开发中占据着核心地位。本教程将深入探讨如何使用Spring和Hibernate进行CRUD（创建、读取、更新和删除）...
Spring-Hibernate-CRUD:使用 MYSQLDB 的 SpringMVC Hibernate CRUD 应用程序
07-07
- 文件名为"Spring-Hibernate-CRUD-master"，表明项目可能源自Git仓库，使用版本控制来管理代码。 为了实现这个项目，你需要熟悉上述每个技术的使用，并理解它们如何协同工作。这包括配置SpringMVC和Hibernate的...
Spring-MVC-CRUD表单提交和ajax：Spring MVC CRUD应用程序（Spring MVC 5.x，hibernate 5.x，Bootstrap 3.x，JQuery，MySql）
01-30
Spring MVC，hibernate 4.x，Bootstrap 3.x，FontAwesome 4.x，JQuery 应用服务器： Tomcat 8，Glassfish 4 D B ： MySQL 5.x的 生成工具： Maven 项目结构： 项目职能： 使用表单提交创建用户： Ajax CRUD： ...
Spring进阶：Spring的CRUD
03-16
**Spring进阶：Spring的CRUD** 在Java企业级开发中，Spring框架是不可或缺的一部分，它为应用程序提供了全面的控制反转（IoC）和面向切面编程（AOP）支持。Spring的CRUD操作，即创建（Create）、读取（Read）、更新...
SpringMVC+Hibernate4+Spring3整合开发实现CRUD
mobingdetong的专栏
03-08 951
·在实现CRUD之前，我想你的开发环境已经搭建好了，我们就不作搭建的说明了，直接进入正题； 一般搭建环境都是项目经理的事情，项目经理搭建完环境，就会把环境放到svn服务器上，你只需要从服务器上检出项目环境开发即可； FileàInportàSVNà从SVN检出项目   我的资源库已经创建好了，你从视图中打开资源库视图创建一个资源库就好了，     选择项目文件夹finish即可；
hibernate框架中的crud
臆想的一只猫
06-20 371
1、什么是crud?        crud代表了save、update、get、delete；也就是所谓的添加、修改、查找、删除。主要被用在描述软件系统中DataBase或者持久层的基本操作功能。2、如何理解crud?        修改时，实际上是修改hibernate中的对象状态。3、 在hibernate中    对象有三种状态：                (1)、瞬时状态：一个实体对...
快速构建SpringBoot项目并整合Hibernate实现CRUD（详细版）
小白菜
12-20 3460
从无到有详细版 1.创建项目（为了方便，使用Maven项目） 新建-选择maven项目-一直下一步，到： 然后点 Finish 完成创建。 2.添加依赖 此时已经创建了一个Maven项目，因为需要使用SpringBoot，我们需要在pom.xml里面添加SpringBoot的依赖 打开pom.xml文件，加入以下依赖（注意标签）： 继承springboot父工程： &l...
使用Hibernate进行CRUD操作
每天就学一点点的博客
04-20 1496
CRUD操作 1、使用hibernate把数据库模型和java对象进行ORM映射，通过配置文件或者注解完成。 2、程序通过hibernate提供的API进行CRUD， C操作对应hibernate方法为save();（添加） R操作对应hibernate方法为get();（查询） U操作对应hibernate方法为update();（修改） D操作对应hibernate方法为delete()。（删...
Spring boot整合Hibernate实现CRUD
qq_44860722的博客
07-19 652
前言！ 我们在前面学习过Mybatis后，搭建起了SSM框架，很多小伙伴在一些招聘网站上看到一些技能要求是掌握SSH框架，所谓的SSH框架就是Spring+SpringMVC+Hibernate。 实际上Hibernate是很容易上手的，我在看了一篇文章后就利用Spring Boot 整合了Hibernate！ 看完这篇文章代码直接复制，立马搭建！！ 什么是Hibernate？ Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映
Spring+SpringMVC+Hibernate整合(封装CRUD操作)
风清扬
07-02 1346
前言：当前Web项目开发的框架主流应该非Spring+SpringMVC+Hibernate莫属，不管是工作还是学习中涉及框架技术，首先是要搭建一套运行环境，虽然网上框架整合的教程很多，但我还是输出此文，一是自己总结整理可巩固理解，二是可供有需要学习的同仁参考。本着负责人的态度，本文所有内容测试通过，运行环境为JDK8+Tomcat8，Spring4.3.9，Hibernate5.2.10. ...
(详细)Hibernate框架的搭建，Hibernate的CRUD操作（一）
u014078192的专栏
05-04 2049
一、框架概述： 框架的优点：开发速度快，规范 后台框架：Hibernate，MyBATIS（iBATIS），EJB 前台框架（MVC）：Struts(1/2)，SpringMVC，JSF Spring框架：Spring，Seam JS框架：JQuery，ExtJS
@RequestMapping —— 请求方式、请求参数、请求头
jvisualvm
08-09 985
映射请求方式、请求参数、请求头   Demo value, method   params, headers      
@RequestMapping —— @RequestHeader注解
jvisualvm
08-10 928
使用@RequestHeader绑定请求报头的属性值 Demo            
Spring Task Scheduling读书笔记
jvisualvm
09-27 396
Task Scheduling in Spring   Introducing the Spring TaskScheduler Abstraction   Relationship between trigger, task, and scheduler   Reference Apress.Pro Spring 4th Edition.2014 - CHAPTER 11 T...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值