jyjiao2007
- 浏览: 102911 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
dreamoftch：
...
对hibernate的理解 -
quanwsx：
对hibernate的理解 -
zxt1985：
太坑爹了……啥都没
**java网络编程 -
Java_zhou：
坑爹啊。。。
**java网络编程 -
juda：
this code can not work rightly ...
Reverse String
对spring的理解，spring的核心概念（原理+三个重要应用）->spring的优势所在
Spring 的原理（反射机制+工厂设计模式）
使用Spring框架，可以通过spring容器来管理对象的创建和使用，可以灵活地将对象注入到其他对象中去
Spring模拟实现代码：
1.Spring核心：
BeanFactory.java:
ClassPathXmlApplicationContext.java
bean.xml:
2. Model层：
User.java
3. DAO层：
UserDAOImpl.java
5. service层:
6. 应用层
Spring模拟实现代码：
1.Spring核心：
BeanFactory.java:
public interface BeanFactory {
public Object getBean(String id);
}
ClassPathXmlApplicationContext.java
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
public class ClassPathXmlApplicationContext implements BeanFactory {
private Map<String , Object> beans = new HashMap<String, Object>();
//IOC Inverse of Control DI Dependency Injection
public ClassPathXmlApplicationContext() throws Exception {
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml")); //构造文档对象
Element root=doc.getRootElement(); //获取根元素HD
List list=root.getChildren("bean");//取名字为disk的所有元素
for(int i=0;i<list.size();i++){
Element element=(Element)list.get(i);
String id=element.getAttributeValue("id");
String clazz=element.getAttributeValue("class");
Object o = Class.forName(clazz).newInstance();
System.out.println(id);
System.out.println(clazz);
beans.put(id, o);
for(Element propertyElement : (List<Element>)element.getChildren("property")) {
String name = propertyElement.getAttributeValue("name"); //userDAO
String bean = propertyElement.getAttributeValue("bean"); //u
Object beanObject = beans.get(bean);//UserDAOImpl instance
String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
System.out.println("method name = " + methodName);
Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
m.invoke(o, beanObject);
}
}
}
public Object getBean(String id) {
return beans.get(id);
}
}
bean.xml:
<beans> <bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl" /> <bean id="userService" class="com.bjsxt.service.UserService" > <property name="userDAO" bean="u"/> </bean> </beans>
2. Model层：
User.java
public class User {
private String username;
private String password;
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;
}
}
3. DAO层：
UserDAOImpl.java
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
public class UserDAOImpl implements UserDAO {
public void save(User user) {
//Hibernate
//JDBC
//XML
//NetWork
System.out.println("user saved!");
}
}
5. service层:
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
public class UserService {
private UserDAO userDAO;
public void add(User user) {
userDAO.save(user);
}
public UserDAO getUserDAO() {
return userDAO;
}
public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}
}
6. 应用层
public class UserServiceTest {
@Test
public void testAdd() throws Exception {
BeanFactory applicationContext = new ClassPathXmlApplicationContext();
UserService service = (UserService)applicationContext.getBean("userService");
User u = new User();
u.setUsername("zhangsan");
u.setPassword("zhangsan");
service.add(u);
}
}
DI：
1 DI的概念
2 DI举例说明
2.1 简单实例
2.2 Spring整合Struts
2.3 Spring整合Hibernate
DI(依赖注入)：对象的实例由spring容器来创建、并注入到使用该对象实例的程序中 或者 由程序员去容器中取出对象的实例；而不需要程序员去创建该对象的实例。
实例1：通过在bean.xml中配置 对象的信息，由spring容器创建对象实例，程序员使用对象时从容器中去取
实例2：通过在bean.xml文件中配置对象A依赖对象B，在对象A中获得一个对象B的实例（注意需要在A中加入B的引用以及B的get和set方法)
bean.xml:
UserService.java:
实例3：属性注入，采用注解和get、set方法:
UserDAOImpl.java:
UserService.java:
bean.xml:
UserServiceTest.java:
2 DI举例说明
2.1 简单实例
2.2 Spring整合Struts
2.3 Spring整合Hibernate
DI(依赖注入)：对象的实例由spring容器来创建、并注入到使用该对象实例的程序中 或者 由程序员去容器中取出对象的实例；而不需要程序员去创建该对象的实例。
实例1：通过在bean.xml中配置 对象的信息，由spring容器创建对象实例，程序员使用对象时从容器中去取
package com.bjsxt.service;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.bjsxt.model.User;
//Dependency Injection
//Inverse of Control
public class UserServiceTest {
@Test
public void testAdd() throws Exception {
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
UserService service = (UserService)ctx.getBean("userService");
User u = new User();
u.setUsername("zhangsan");
u.setPassword("zhangsan");
service.add(u);
}
}
实例2：通过在bean.xml文件中配置对象A依赖对象B，在对象A中获得一个对象B的实例（注意需要在A中加入B的引用以及B的get和set方法)
bean.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl">
</bean>
<bean id="userService" class="com.bjsxt.service.UserService">
<property name="userDAO" ref="u" />
</bean>
</beans>
UserService.java:
package com.bjsxt.service;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
public class UserService {
private UserDAO userDAO; //加入userDAO的引用
public void add(User user) {
userDAO.save(user);
}
public UserDAO getUserDAO() { //getUserDAO
return userDAO;
}
public void setUserDAO(UserDAO userDAO) { //setUserDAO
this.userDAO = userDAO;
}
}
实例3：属性注入，采用注解和get、set方法:
UserDAOImpl.java:
package com.bjsxt.dao.impl;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
public class UserDAOImpl implements UserDAO {
public void save(User user) {
//Hibernate
//JDBC
//XML
//NetWork
System.out.println("user saved!");
}
}
UserService.java:
package com.bjsxt.service;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
public class UserService {
private UserDAO userDAO;
public void init() {
System.out.println("init");
}
public void add(User user) {
userDAO.save(user);
}
public UserDAO getUserDAO() {
return userDAO;
}
@Resource
public void setUserDAO( UserDAO userDAO) {
this.userDAO = userDAO;
}
public void destroy() {
System.out.println("destroy");
}
}
bean.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config />
<bean id="userDAO" class="com.bjsxt.dao.impl.UserDAOImpl">
</bean>
<bean id="userService" class="com.bjsxt.service.UserService" >
</bean>
</beans>
UserServiceTest.java:
import com.bjsxt.model.User;
//Dependency Injection
//Inverse of Control
public class UserServiceTest {
@Test
public void testAdd() throws Exception {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
UserService service = (UserService)ctx.getBean("userService");
service.add(new User());
ctx.destroy();
}
}
AOP：
1 AOP的概念
2 AOP的原理(AOP与动态代理)
2.1 模拟代码
2.2 Spring中的AOP的相关概念
2.3 Spring中的AOP的应用举例
1 AOP的概念:
AOP: 面向切面编程 Aspect-Oriented-Programming
例如：在一个方法执行之前或者之后加一些代码 (一些业务逻辑)，即动态织入一些额外的代码。
如何实现呢？ 1. 继承原有类 2. 采用组合的方式，创建原有类的一个代理 3. 使用拦截器（面向切面编程）
好处：可以动态的添加和删除在切面上的逻辑，而不影响到原来的代码。
AOP应用实例： Servlet Filter, Struts2 的Interceptor
2 AOP的原理(AOP与动态代理)
2.1 模拟AOP的实现代码（采用动态代理的方法）
为什么要用动态代理？
拦截器可以动态地代理所有需要代理的类以及方法，这些类需要在bean.xml文件中配置该拦截器。
实现：用JDK提供的 Proxy类和 InvocationHandler类来实现
拦截器： LogInterceptor.java
产生代理对象：
2.2 Spring中的AOP的相关概念
概念：
1. joinpoint: 代码执行过程中被拦截的地方 (例如：被拦截的方法之前)
2. pointcut: joinpoint(切入点)的一个集合。
例如：
@Pointcut("execution(public * com.bjsxt.service..*.add(..))")
public void myMethod(){}; (pointcut的名字)
3. aspect: 切面上的逻辑。例如:拦截器Interceptor
5. Target: 被代理的对象
6. weave: 织入
常见的Annotation:
@before: 方法执行前
@AfterThrowing: catch到异常时执行
@AfterReturning: 在方法返回之前
@After: finally时执行的代码
@Around: 在执行之前和之后都可以执行。 回忆servlet filter
@Pointcut：为切面类的方法配置需要被拦截的点
2.3 Spring中的AOP的应用实例：
2 AOP的原理(AOP与动态代理)
2.1 模拟代码
2.2 Spring中的AOP的相关概念
2.3 Spring中的AOP的应用举例
1 AOP的概念:
AOP: 面向切面编程 Aspect-Oriented-Programming
例如：在一个方法执行之前或者之后加一些代码 (一些业务逻辑)，即动态织入一些额外的代码。
如何实现呢？ 1. 继承原有类 2. 采用组合的方式，创建原有类的一个代理 3. 使用拦截器（面向切面编程）
好处：可以动态的添加和删除在切面上的逻辑，而不影响到原来的代码。
AOP应用实例： Servlet Filter, Struts2 的Interceptor
2 AOP的原理(AOP与动态代理)
2.1 模拟AOP的实现代码（采用动态代理的方法）
为什么要用动态代理？
拦截器可以动态地代理所有需要代理的类以及方法，这些类需要在bean.xml文件中配置该拦截器。
实现：用JDK提供的 Proxy类和 InvocationHandler类来实现
拦截器： LogInterceptor.java
package com.bjsxt.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class LogInterceptor implements InvocationHandler {
private Object target;
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
public void beforeMethod(Method m) {
System.out.println(m.getName() + " start");
}
public Object invoke(Object proxy, Method m, Object[] args)
throws Throwable {
beforeMethod(m); // 加入新的逻辑
m.invoke(target, args); // 调用被代理对象的方法
return null;
}
}
产生代理对象：
@Test
public void testProxy() {
UserDAO userDAO = new UserDAOImpl(); //被代理对象
LogInterceptor li = new LogInterceptor(); //拦截器
li.setTarget(userDAO);
// 产生代理对象
UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
System.out.println(userDAOProxy.getClass());
userDAOProxy.delete();
userDAOProxy.save(new User());
}
2.2 Spring中的AOP的相关概念
概念：
1. joinpoint: 代码执行过程中被拦截的地方 (例如：被拦截的方法之前)
2. pointcut: joinpoint(切入点)的一个集合。
例如：
@Pointcut("execution(public * com.bjsxt.service..*.add(..))")
public void myMethod(){}; (pointcut的名字)
3. aspect: 切面上的逻辑。例如:拦截器Interceptor
5. Target: 被代理的对象
6. weave: 织入
常见的Annotation:
@before: 方法执行前
@AfterThrowing: catch到异常时执行
@AfterReturning: 在方法返回之前
@After: finally时执行的代码
@Around: 在执行之前和之后都可以执行。 回忆servlet filter
@Pointcut：为切面类的方法配置需要被拦截的点
2.3 Spring中的AOP的应用实例：
package com.bjsxt.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LogInterceptor {
@Pointcut("execution(public * com.bjsxt.service..*.add(..))")
public void myMethod(){};
@Before("myMethod()")
public void before() {
System.out.println("method before");
}
@Around("myMethod()")
public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("method around start");
pjp.proceed();
System.out.println("method around end");
}
}
Spring+Hibernate的整合--示例程序
1.示例1
配置文件：
将dataSource的Bean 和sessionFactory(Hibernate3.AnnotationSessionFactoryBean) 配置到 bean.xml中
User.java
UserDAO.java:
UserDAOImpl.java
UserService.java
UserServiceTest .java
---------------------------------------------------------------------------------------------------------------
示例2: 声明式事务管理
1. 日志信息保存和用户信息保存应在一个事务中进行处理，因此，事务处理应该放在service层来处理
2. 需要使用@Transactional标签
3. 在出现RuntimeException时事务会回滚，Hibernate中的异常都是RuntimeException
LogDAOImpl:
UserDAOImpl:
UserService.java
-------------------------------------------------------------------------------------------------
示例3：HibernateTemplate：
Spring对Hibernate的一种简单封装，制作一个模板。
封装的部分：
bean.xml：
UserDAOImpl.java
模板方式的模拟实现：
示例5：HibernateDaoSupport： 参考hibernate--2部分的代码
配置文件：
将dataSource的Bean 和sessionFactory(Hibernate3.AnnotationSessionFactoryBean) 配置到 bean.xml中
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="annotatedClasses">
<list>
<value>com.bjsxt.model.User</value><!--注解的实体类-->
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
User.java
package com.bjsxt.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class User {
private int id;
private String name;
@Id
@GeneratedValue
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;
}
}
UserDAO.java:
package com.bjsxt.dao;
import com.bjsxt.model.User;
public interface UserDAO {
public void save(User user);
}
UserDAOImpl.java
package com.bjsxt.dao.impl;
import java.sql.SQLException;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Component;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
@Component("u")
public class UserDAOImpl implements UserDAO {
private SessionFactory sessionFactory;
public SessionFactory getSessionFactory() {
return sessionFactory;
}
@Resource
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public void save(User user) {
System.out.println("session factory class:" + sessionFactory.getClass());
Session s = sessionFactory.openSession();
s.beginTransaction();
s.save(user);
s.getTransaction().commit();
System.out.println("user saved!");
//throw new RuntimeException("exeption!");
}
}
UserService.java
package com.bjsxt.service;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
@Component("userService")
public class UserService {
private UserDAO userDAO;
public void init() {
System.out.println("init");
}
public void add(User user) {
userDAO.save(user);
}
public UserDAO getUserDAO() {
return userDAO;
}
@Resource(name="u")
public void setUserDAO( UserDAO userDAO) {
this.userDAO = userDAO;
}
public void destroy() {
System.out.println("destroy");
}
}
UserServiceTest .java
package com.bjsxt.service;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.bjsxt.model.User;
//Dependency Injection
//Inverse of Control
public class UserServiceTest {
@Test
public void testAdd() throws Exception {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
UserService service = (UserService)ctx.getBean("userService");
System.out.println(service.getClass());
service.add(new User());
ctx.destroy();
}
}
---------------------------------------------------------------------------------------------------------------
示例2: 声明式事务管理
1. 日志信息保存和用户信息保存应在一个事务中进行处理，因此，事务处理应该放在service层来处理
2. 需要使用@Transactional标签
3. 在出现RuntimeException时事务会回滚，Hibernate中的异常都是RuntimeException
<?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: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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<context:annotation-config />
<context:component-scan base-package="com.bjsxt" />
<!--
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/spring" />
<property name="username" value="root" />
<property name="password" value="bjsxt" />
</bean>
-->
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:jdbc.properties</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="annotatedClasses">
<list>
<value>com.bjsxt.model.User</value>
<value>com.bjsxt.model.Log</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:annotation-driven transaction-manager="txManager"/>
</beans>
LogDAOImpl:
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Component;
import com.bjsxt.dao.LogDAO;
import com.bjsxt.model.Log;
@Component("logDAO")
public class LogDAOImpl implements LogDAO {
private SessionFactory sessionFactory;
public SessionFactory getSessionFactory() {
return sessionFactory;
}
@Resource
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public void save(Log log) {
Session s = sessionFactory.getCurrentSession();
s.save(log);
//throw new RuntimeException("error!");
}
}
UserDAOImpl:
import java.sql.SQLException;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Component;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
@Component("u")
public class UserDAOImpl implements UserDAO {
private SessionFactory sessionFactory;
public SessionFactory getSessionFactory() {
return sessionFactory;
}
@Resource
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public void save(User user) {
Session s = sessionFactory.getCurrentSession();
s.save(user);
//throw new RuntimeException("exeption!");
}
}
UserService.java
package com.bjsxt.service;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.bjsxt.dao.LogDAO;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.Log;
import com.bjsxt.model.User;
@Component("userService")
public class UserService {
private UserDAO userDAO;
private LogDAO logDAO;
public void init() {
System.out.println("init");
}
public User getUser(int id) {
return null;
}
@Transactional(readOnly=true)
public void add(User user) {
userDAO.save(user);
Log log = new Log();
log.setMsg("a user saved!");
logDAO.save(log);
}
public UserDAO getUserDAO() {
return userDAO;
}
@Resource(name="u")
public void setUserDAO( UserDAO userDAO) {
this.userDAO = userDAO;
}
public LogDAO getLogDAO() {
return logDAO;
}
@Resource
public void setLogDAO(LogDAO logDAO) {
this.logDAO = logDAO;
}
public void destroy() {
System.out.println("destroy");
}
}
-------------------------------------------------------------------------------------------------
示例3：HibernateTemplate：
Spring对Hibernate的一种简单封装，制作一个模板。
封装的部分：
bean.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: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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<context:annotation-config />
<context:component-scan base-package="com.bjsxt" />
<!--
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/spring" />
<property name="username" value="root" />
<property name="password" value="bjsxt" />
</bean>
-->
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:jdbc.properties</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--
<property name="annotatedClasses">
<list>
<value>com.bjsxt.model.User</value>
<value>com.bjsxt.model.Log</value>
</list>
</property>
-->
<property name="packagesToScan">
<list>
<value>com.bjsxt.model</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="txManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<aop:config>
<aop:pointcut id="bussinessService"
expression="execution(public * com.bjsxt.service..*.*(..))" />
<aop:advisor pointcut-ref="bussinessService"
advice-ref="txAdvice" />
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="getUser" read-only="true" />
<tx:method name="add*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</beans>
UserDAOImpl.java
package com.bjsxt.dao.impl;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;
@Component("u")
public class UserDAOImpl implements UserDAO {
private HibernateTemplate hibernateTemplate;
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
@Resource
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
public void save(User user) {
hibernateTemplate.save(user);
//throw new RuntimeException("exeption!");
}
}
模板方式的模拟实现：
示例5：HibernateDaoSupport： 参考hibernate--2部分的代码
在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得
HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或
OpenSessionInViewInterceptor。
HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或
OpenSessionInViewInterceptor。
spring中的Bean的生命周期管理：
1.Bean的作用域可以通过Bean标签的scope属性进行设置，Bean的作用域包括：
默认情况下scope="singleton"，那么该Bean是单例，任何人获取该Bean实例的都为同一个实例；
scope="prototype"，任何一个实例都是新的实例；
scope="request"，在WEB应用程序中，每一个实例的作用域都为request范围；
scope="session",在WEB应用程序中，每一个实例的作用域都为session范围；
注意：在默认情况下，Bean实例在被Spring容器初始化的时候，就会被实例化，默认调用无参数的构造方法。在其它情况下，Bean将会
在获取实例的时候才会被实例化。
2.Bean可以通过指定属性init-method指定初始化后执行的方法，以及通过指定属性destroy-method销毁时执行的方法。
语法：<bean .... destroy-method="销毁时调用的方法名" init-method="初始化后执行的方法名"/>
分享到：
发表评论
-
Struts2 -- 2
2010-10-16 12:13 927Struts2 接收参数的方式： 1. action的属 ... -
s-s-h
2010-10-07 13:52 948SSH整合--用户登录的例子：---------------- ... -
Struts.xml
2010-10-06 18:08 782<?xml version="1.0" ... -
Hibernate -- 2
2010-09-26 11:44 893=====================Hibernate面 ... -
对hibernate的理解
2010-09-10 18:27 4591================映射关系设置========= ... -
#对struts框架的理解
2010-09-08 15:39 1116struts框架和传统的web应 ... -
SSH整合
2009-05-09 00:16 142本次配置环境：Myeclipse5.5、MySQL5.0、St ... -
Struts配置文件详解
2009-02-19 01:08 76Struts应用采用两个基于X ... -
Action类详解
2009-02-18 23:04 1041.Action类 org.apache.act ...
相关推荐
- **使用 Spring MVC 和 Spring Web**：Spring Boot 提供了对 RESTful API 的强大支持，可以使用 Spring MVC 和 Spring Web 来完成 RESTful 服务的开发。通过简单的注解即可实现 REST 接口的功能。 ##### 2.5 集成...
这本书是Spring框架开发的必备指南，从基础知识到高级应用都有涉及，并且配有大量的实例帮助读者理解和掌握Spring框架的核心概念和技术。 ### 一、Spring 概览 #### 1.1 Spring 的起源与发展 - **1.1.1 Spring ...
以下是对Spring框架中关键JAR包的详细解析，帮助开发者更好地理解和运用这些资源。 #### spring-core.jar 此JAR包是Spring框架的核心容器，提供了基本的依赖注入（Dependency Injection，DI）功能。它包含...
### Spring框架学习路线 #### Spring框架概述 Spring是一个开源的Java/Java EE全功能栈的应用框架，是...对于Java后台开发人员而言，深入学习和理解Spring框架，不仅可以提高开发效率，还能提升应用的性能和可维护性。
- **2005年**：Spring框架2.0发布，增加了对Java 5的支持。 - **2015年3月**：Spring框架4.1.6发布，这是本教程所基于的版本。 - **后续版本**：Spring框架持续发展，引入了更多的特性和改进，以适应不断变化的技术...
根据给定文件的信息，我们可以详细地探讨Spring Cloud及其相关组件的知识点。 ### Spring Cloud Spring Cloud 是一套完整的微服务开发工具包...通过对这些工具的理解和掌握，开发者可以更加高效地构建现代应用程序。
### Spring框架核心概念 #### 1. Spring框架简介 Spring框架是一个开源的Java平台，用于构建企业级应用程序。它提供了一种简洁的方式来管理组件、...希望本文能够帮助大家更好地理解和掌握Spring及其生态系统的知识。
**Spring全家桶与Spring Boot详解** 在现代Java开发领域，Spring框架无疑是最为广泛使用的轻量级应用框架之一。...通过深入理解并熟练运用Spring Boot，开发者可以大大提高项目的开发速度和质量。
- **反转控制 (IoC)**：Spring通过依赖注入实现了IoC，这有助于降低组件之间的耦合度，使得代码更易于理解、维护和测试。 - **面向切面编程 (AOP)**：Spring支持AOP，可以帮助开发者将跨多个业务组件的关注点进行...
为了更好地理解Spring框架的使用，以下是一个简单的Spring Hello World示例： 1. **创建项目**：首先，在IDE中创建一个新的Java项目，命名为`springHelloWorld`。 2. **添加Spring依赖**：将Spring框架的JAR包...
根据给定的信息，我们可以深入探讨Spring框架中与Hibernate集成的相关知识点，特别关注“HibernateDaoSupport”类及其在Spring环境中的应用。...这些内容有助于更好地理解和运用Spring框架与Hibernate的集成开发。
根据给定的文件信息，我们可以提炼出Spring 2系列的核心知识点和更新内容，这将有助于理解和掌握Spring框架在2.0版本中的主要特性和改进。 ### Spring 2系列概述 Spring框架是Java平台上一个开源的应用框架，其...
### Spring系统架构与设计模式之原码解析：IOC容器 #### 概述 Spring框架作为企业级应用开发中不可或缺的...通过对Spring IOC容器深入的理解，不仅有助于提高代码质量和可维护性，还能更好地应对日益复杂的业务需求。
根据提供的文件信息，“Spring 3.0教程.pdf”是一份关于Spring框架的教程文档，主要目的是帮助读者理解和掌握Spring框架的基础知识与应用技巧。虽然给定的部分内容并未包含实际的技术细节，但从标题、描述以及标签来...
通过系统地学习这些知识点，开发者将能够更好地理解和应用Spring框架，从而提高自己的编程技能和项目实施能力。希望每位学习者都能从中受益，掌握Spring框架的核心技术，为自己的职业生涯打下坚实的基础。
根据提供的标题、描述以及部分内文，我们可以提炼出与Spring框架相关的多个知识点。下面将对这些知识点进行详细的阐述。 ### Spring框架概述 ...希望上述内容能够帮助大家更好地理解和掌握Spring框架的相关知识。
Spring的核心优势在于其对依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）的支持，这使得开发者可以更加专注于业务逻辑的实现，而无需过多关注底层架构和组件间的耦合。...
### Spring框架概述及核心知识点详解 #### Spring框架简介 Spring框架是一种轻量级的Java开发框架，主要目的是解决企业级...通过深入理解Spring框架的核心原理和实践应用，开发者可以更高效地构建高质量的企业级应用。
### Spring框架概述及核心特性 #### 1. 什么是Spring框架？Spring框架有哪些主要模块？...通过深入理解上述知识点，可以帮助开发者更好地掌握Spring框架的核心原理和技术细节，从而在实际项目中更加高效地使用Spring。