框架整合 | rain

编写spring配置文件

<!-- 
     	事务管理器
     	    告诉spring容器开启事务用什么技术
      -->
     <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
     	<property name="sessionFactory">
     		<ref bean="sessionFactory"/>
     	</property>
     </bean>
     
     <tx:advice id="tx" transaction-manager="transactionManager">
     	<tx:attributes>
     		<tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
     	</tx:attributes>
     </tx:advice>
     
     <aop:config>
     	<aop:pointcut expression="execution(* cn.itcast.shoa.service.impl.*.*(..))" id="perform"/>
    	<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
     </aop:config>

整合spring框架及测试

编写dao接口及其实现类

package cn.itcast.shoa.dao;

import cn.itcast.shoa.domain.Person;

public interface PersonDao {
	
	public void savePerson(Person person);
	
}

package cn.itcast.shoa.dao.impl;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import cn.itcast.shoa.dao.PersonDao;
import cn.itcast.shoa.domain.Person;

public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao{

	@Override
	public void savePerson(Person person) {
		// TODO Auto-generated method stub
		this.getHibernateTemplate().save(person);
	}

}

编写service接口及其实现类

package cn.itcast.shoa.service;

import cn.itcast.shoa.domain.Person;

public interface PersonService {
	
	public void savePerson(Person person);
	
}

package cn.itcast.shoa.service.impl;

import cn.itcast.shoa.dao.PersonDao;
import cn.itcast.shoa.domain.Person;
import cn.itcast.shoa.service.PersonService;

public class PersonServiceImpl implements PersonService{
	
	private PersonDao personDao;

	public PersonDao getPersonDao() {
		return personDao;
	}

	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}

	@Override
	public void savePerson(Person person) {
		// TODO Auto-generated method stub
		this.personDao.savePerson(person);
	}
	
}

新建spring配置文件applicationContext-person.xml并将dao层和service层的类放入到spring的配置文件中

<bean id="personDao" class="cn.itcast.shoa.dao.impl.PersonDaoImpl">
	<property name="sessionFactory">
	<ref bean="sessionFactory"/>
	</property>
</bean>

<bean id="personService" class="cn.itcast.shoa.service.impl.PersonServiceImpl">
	<property name="personDao">
		<ref bean="personDao"/>
	</property>
</bean>

新建测试类进行测试personService，看测试的对象是否是代理对象

package cn.itcast.shoa.test;

import org.junit.Test;

import cn.itcast.shoa.service.PersonService;

public class PersonTest extends SpringUtils{
	@Test
	public void testPersonService() {	
		PersonService personService = (PersonService) context.getBean("personService");
		System.out.println(personService);	
	}
}

整合struts2框架及测试

编写Action类

package cn.itcast.shoa.struts2.action;

import com.opensymphony.xwork2.ActionSupport;

import cn.itcast.shoa.domain.Person;
import cn.itcast.shoa.service.PersonService;

public class PersonAction extends ActionSupport{
	
	private PersonService personService;

	public void setPersonService(PersonService personService) {
		this.personService = personService;
	}
	
	public String savePerson() {
		Person person = new Person();
		person.setName("Eva");
		this.personService.savePerson(person);
		return null;
	}

}

将Action放入Spring配置文件applicationContext-person.xml中

<bean id="personAction" class="cn.itcast.shoa.struts2.action.PersonAction">
		<property name="personService">
			<ref bean="personService"/>
		</property>
	</bean>

编写struts.xml配置文件放入总目录

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
	<constant name="struts.devMode" value="true"/>
	<constant name="struts.ui.theme" value="simple"/>
	
	<include file="struts/struts-person.xml"></include>
</struts>

分层写struts-person.xml配置文件，将Action写入配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
	<bean type="com.opensymphony.xwork2.ObjectFactory" 
		name="aaa" 
		class="cn.itcast.shoa.struts.action.CreateActionBean" />
	<constant name="struts.objectFactory" value="aaa"></constant>
	<package name="person" namespace="/" extends="struts-default">
		<action name="personAction_*" method="{1}" class="personAction">
			
		</action>
	</package>
</struts>

编写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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 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>sh05oa_maven</display-name>
  <listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring/applicationContext.xml</param-value>
	</context-param>
	
	<filter>
		<filter-name>OpenSessionInViewFilter</filter-name>
		<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>OpenSessionInViewFilter</filter-name>
		<url-pattern>*.action</url-pattern>
	</filter-mapping>

	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
  <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>
</web-app>

启动服务器测试能否成功运行

struts2

是一个mvc框架，是一个aop容器。

struts2插件机制

在web.xml配置文件中找到过滤器配置项

过滤器中有init方法与doFilter方法，服务器启动时执行init方法。

加载了org/apache/struts/default.properties文件
1. 加载了3种struts2配置文件
  - struts-default.xml
  - struts-plugin.xml
  - struts.xml
2. 配置文件的特点
  - struts-default.xml文件是系统默认的配置文件
  - struts-plugin.xml是插件机制的配置文件，可以有多个
  - struts.xml是开发中用的的配置文件
  这3种配置文件都在classpath的根目录存放
  
  这3种配置文件的dtd约束都一样，所以可以出现相同的元素，如果出现相同的元素，后者覆盖前者
  
  struts-plugin.xml文件可以有很多个，而且通常是在lib下的jar包中出现

对象工厂objectFactory

struts2创建action的最底层方法

1
2
3

public Object buildAction(String actionName, String namespace, ActionConfig config, Map<String, Object> extraContext) throws Exception {
				return buildBean(config.getClassName(), extraContext);
			    }

struts2创建结果集的最底层方法

1
2
3

public Result buildResult(ResultConfig resultConfig, Map<String, Object> extraContext) throws Exception {
		    
		    }

struts2创建拦截器的最底层方法

1 2	public Interceptor buildInterceptor(InterceptorConfig interceptorConfig, Map<String, String> interceptorRefParams) throws ConfigurationException { }

静态注入
1. 在struts2的配置文件中有一些元素
  - bean 元素可以配置多个bean
    1
    2
    3
    <bean type="com.opensymphony.xwork2.util.ValueStackFactory"
    name="struts"
    class="com.opensymphony.xwork2.ognl.OgnlValueStackFactory" />
    说明：
    1. 值栈的产生工厂是OgnlValueStackFactory
    2. 该类在tomcat容器启动的时候就被加载了，所以只加载一次
    3. 通过该类就把值栈的产生工厂赋值到struts2容器中了，这个过程称为注入
    4. 所以这种行为称为”静态注入”
  - constant 常量
  - include 包含
  - package
    - 声明一个action
    - 声明一个拦截器
    - 声明一个结果集

改变action的产生方式

在default.properties文件中有一个配置项

struts.objectFactory该配置项指明了对象工厂

写一个类继承ObjectFactory，重写buildAction方法

public class CreateActionBean extends ObjectFactory{
				@Override
				public Object buildAction(String actionName, String namespace,
						ActionConfig config, Map<String, Object> extraContext)
						throws Exception {
					// TODO Auto-generated method stub
					System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
					return null;
				}
			}

在struts2的配置文件中利用bean元素把CreateActionBean放入struts2容器中

1
2
3

<bean type="com.opensymphony.xwork2.ObjectFactory" 
			name="aaa" 
			class="cn.itcast.shoa.struts.action.CreateActionBean" />

在配置文件中引入常量struts.objectFactory

1	<constant name="struts.objectFactory" value="aaa"></constant>

分析struts2的插件机制

提供了一个jar包

struts2-spring-plugin-2.3.1.2.jar

在jar包的根目录下存放了一个文件

<bean type="com.opensymphony.xwork2.ObjectFactory" 
				name="spring" 
				class="org.apache.struts2.spring.StrutsSpringObjectFactory" />
    			<constant name="struts.objectFactory" value="spring" />

重新定义了对象工厂

如果一个框架想要和struts2进行整合，提供一个struts-plugin.xml文件，再提供了一个jar包，该配置文件在jar包的根目录下，然后把该jar包放入到lib下就可以了

CannotLoadBeanClassException与ClassNotFoundException找不到类异常

org.springframework.beans.factory.CannotLoadBeanClassException: Cannot find class [cn.itcast.shoa.struts2.action.PersonAction] for bean with name 'personAction' defined in class path resource [spring/applicationContext-person.xml]; nested exception is java.lang.ClassNotFoundException: cn.itcast.shoa.struts2.action.PersonAction

Unable to load configuration. - bean - 无法加载配置文件中的bean

为什么会有接口、抽象类、实现类这样的组织结果：

接口是用来定义标准的
- 得到事务
- 事务的回滚
- 事务的提交
抽象类
- 实现共同的方法
- 在不同的实现方法的时候提供抽象方法
- 具体到事务
  1. 得到事务是抽象方法
    - getTransaction
  2. 事务的提交在该抽象类中得到了实现
    - commit
  3. 事务的回滚在该抽象类中得到了实现
    - rollback
  说明：只要得到事务以后，事务的提交和回滚都是一样的操作。
  
  但是不同框架得到事务的方法是不一样的。

spring容器为什么会提供接口呢？

实现完全的面向接口编程。任何一个数据库连接池框架必须实现DateSource接口。