Spring2.5(2)

最新推荐文章于 2021-08-06 20:32:54 发布

花开不合阳春暮

最新推荐文章于 2021-08-06 20:32:54 发布

阅读量213

点赞数

分类专栏： # Spring 文章标签： spring

本文链接：https://blog.csdn.net/wszcy199503/article/details/54861516

版权

Spring 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

AOP中的概念
Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)
Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知
Target(目标对象):代理的目标对象
Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.
Introduction(引入):在不修改类代码的前提下,Introduction可以在运行期为类动态地添加一些方法或Field.
使用Spring进行面向切面（AOP）编程
要进行AOP编程，首先我们要在spring的配置文件中引入aop命名空间：
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
</beans>
Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：
基于XML配置方式声明切面。
基于注解方式声明切面。
基于注解方式声明切面
首先启动对@AspectJ注解的支持(蓝色部分)：

<beansxmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
         http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<aop:aspectj-autoproxy/>
<bean id="orderservice"class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
</beans>

@Aspect
public class LogPrint {
@Pointcut("execution(* cn.itcast.service..*.*(..))")
private void anyMethod() {}//声明一个切入点
@Before("anyMethod() && args(userName)")//定义前置通知
public void doAccessCheck(String userName) {
}
@AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知
public void doReturnCheck(String revalue) {
}
@AfterThrowing(pointcut="anyMethod()",throwing="ex")//定义例外通知
    public voiddoExceptionAction(Exception ex) {
}
@After("anyMethod()")//定义最终通知
public void doReleaseAction() {
}
@Around("anyMethod()")//环绕通知
public Object doBasicProfiling(ProceedingJoinPoint pjp) throwsThrowable {
return pjp.proceed();
}
}

基于基于XML配置方式声明切面
public class LogPrint {
public void doAccessCheck() {}定义前置通知
public void doReturnCheck() {}定义后置通知
public voiddoExceptionAction() {}定义例外通知
public void doReleaseAction() {}定义最终通知
public Object doBasicProfiling(ProceedingJoinPoint pjp) throwsThrowable {
return pjp.proceed();环绕通知
}
}

<bean id="orderservice"class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
<aop:config>
  <aop:aspect id="myaop" ref="log">
  <aop:pointcut id="mycut" expre ssion="execution(* cn.itcast.service..*.*(..))"/>
 
  <aop:after-returning pointcut-ref="mycut"method="doReturnCheck "/>
  <aop:after-throwing pointcut-ref="mycut"method="doExceptionAction"/>
  <aop:after pointcut-ref="mycut"method=“doReleaseAction"/>
  <aop:around pointcut-ref="mycut"method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>

Spring+JDBC组合开发
使用Spring+JDBC集成步骤如下:
配置数据源,如:
<bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close">
<propertyname="driverClassName" value="org.gjt.mm.mysql.Driver"/>
<property name="url"value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
<propertyname="username" value="root"/>
<propertyname="password" value="123456"/>
.....略
</bean>
配置事务。配置事务时，需要在xml配置文件中引入用于声明事务的tx命名空间(见下页),事务的配置方式有两种：注解方式和基于XML配置方式。
在spring配置文件中引入用于声明事务的tx命名空间
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd
配置数据源

<bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close">
    <propertyname="driverClassName" value="org.gjt.mm.mysql.Driver"/>
    <property name="url"value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
    <propertyname="username" value="root"/>
    <propertyname="password" value="123456"/>
     <!--连接池启动时的初始值 -->
<property name="initialSize" value="1"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="500"/>
<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止-->
<property name="maxIdle" value="2"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请-->
<property name="minIdle" value="1"/>
  </bean>

使用<context:property-placeholderlocation=“jdbc.properties”/>属性占位符
使用属性占位符方式配置数据源

<context:property-placeholderlocation=“jdbc.properties”/> 
 <bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close">
   <propertyname="driverClassName" value="${driverClassName}"/>
    <property name="url"value="${url}"/>
    <propertyname="username" value="${username}"/>
    <propertyname="password" value="${password}"/>
     <!--连接池启动时的初始值 -->
<property name="initialSize" value="${initialSize}"/>
<!-- 连接池的最大值 -->
<property name="maxActive" value="${maxActive}"/>
<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止-->
<property name="maxIdle" value="${maxIdle}"/>
<!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请-->
<property name="minIdle" value="${minIdle}"/>
  </bean>

采用注解方式配置事务
采用注解方式
<bean id="txManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource"ref="dataSource"/>
</bean>
<!– 采用@Transactional注解方式使用事务 -->
<tx:annotation-driventransaction-manager="txManager"/>
@Service @Transactional
public class PersonServiceBean implements PersonService{
}
采用基于XML方式配置事务

<bean id="txManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource"ref="dataSource"/>
</bean>
<aop:config>
  <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  <aop:advisor advice-ref="txAdvice"pointcut-ref="transactionPointcut"/>
</aop:config> 
<tx:advice id="txAdvice"transaction-manager="txManager">
 <tx:attributes>
   <tx:method name="get*"read-only="true" propagation="NOT_SUPPORTED"/>
   <tx:methodname="*"/>
 </tx:attributes>
</tx:advice>

使用JdbcTemplate进行insert/update/delete操作

@Service @Transactional
public class PersonServiceBean implements PersonService{
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
   this.jdbcTemplate = newJdbcTemplate(dataSource);
}
    //添加
public void save(Person person) throws Exception{
jdbcTemplate.update("insert into person (name)values(?)", 
new Object[]{person.getName()}, newint[]{java.sql.Types.VARCHAR});
}
}

使用JdbcTemplate获取一条记录

@Service @Transactional
public class PersonServiceBean implements PersonService{
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
   this.jdbcTemplate = newJdbcTemplate(dataSource);
}
  public Person getPerson(Integer id){
RowMapper rowMapper = new RowMapper(){
public Object mapRow(ResultSet rs, int rowNum) throwsSQLException {
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
return person;
}
};
return (Person)jdbcTemplate.queryForObject("select * fromperson where id=?", 
new Object[]{id}, new int[]{java.sql.Types.INTEGER},rowMapper);
}}

使用JdbcTemplate获取多条记录

@Service @Transactional
public class PersonServiceBean implements PersonService{
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
   this.jdbcTemplate = newJdbcTemplate(dataSource);
}
public List<Person> getPersons(){
RowMapper rowMapper = new RowMapper(){
public Object mapRow(ResultSet rs, int rowNum) throwsSQLException {
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
return person;
}
};
return jdbcTemplate.query("select * from person",rowMapper);
}
}

事务传播属性
REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。
NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。
REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。
MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。
Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。
NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,则按REQUIRED属性执行.它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效
数据库系统提供了四种事务隔离级
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，ReadUncommited的隔离级别最低。大多数据库默认的隔离级别为ReadCommited，如SqlServer，当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql
Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。
Read Commited：读已提交数据(会出现不可重复读和幻读)
Repeatable Read：可重复读(会出现幻读)
Serializable：串行化

脏读：一个事务读取到另一事务未提交的更新新据。
不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。
幻读：一个事务读取到另一事务已提交的insert数据。
Spring2.5+Hibernate3.3+Struts1.3整合开发
hibernate核心安装包下的:
hibernate3.jar
lib\required\*.jar
lib\optional\ehcache-1.2.3.jar
hibernate 注解安装包下的
lib\test\slf4j-log4j12.jar
Spring安装包下的
dist\spring.jar
dist\modules\spring-webmvc-struts.jar
lib\jakarta-commons\commons-logging.jar、commons-dbcp.jar、commons-pool.jar
lib\aspectj\aspectjweaver.jar、aspectjrt.jar
lib\cglib\cglib-nodep-2.1_3.jar
lib\j2ee\common-annotations.jar
lib\log4j\log4j-1.2.15.jar
Struts
下载struts-1.3.8-lib.zip，需要使用到解压目录下的所有jar，建议把jstl-1.0.2.jar和standard-1.0.2.jar更换为1.1版本。Spring中已经存在一个antlr-2.7.6.jar，所以把struts中的antlr-2.7.2.jar删除，避免jar冲突。
数据库驱动jar

<bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close">
 ..... 略 </bean>
<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource"ref="dataSource"/>
    <property name="mappingResources">
   <list>
    <value>cn/itcast/bean/Person.hbm.xml</value>
   </list>
    </property>
    <property name="hibernateProperties">
   <value>
      hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
      hibernate.hbm2ddl.auto=update
      hibernate.show_sql=false
      hibernate.format_sql=false
    </value>
    </property>
</bean>
<bean id="txManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory"ref="sessionFactory"/>
</bean>
<tx:annotation-driven transaction-manager="txManager"/>

实体bean配置模版.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
       "-//Hibernate/Hibernate Mapping DTD3.0//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.bean">
    <class name="Person"table="person">
       <id name="id" type="integer" >
           <generatorclass="native"/>
       </id>
       <property name="name" length="10"not-null="true"/>
    </class>
</hibernate-mapping>

Hibernate二级缓存的配置

<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource"ref="dataSource"/>
<property name="mappingResources">
   <list>
    <value>cn/itcast/bean/Person.hbm.xml</value>
   </list>
</property>
    <property name="hibernateProperties">
   <value>
      hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
      hibernate.hbm2ddl.auto=update
      hibernate.show_sql=false
      hibernate.format_sql=false
      hibernate.cache.use_second_level_cache=true
            hibernate.cache.use_query_cache=false
           hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
    </value>
    </property>
</bean>

在需要缓存的实体bean配置文件中加入缓存配置项

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
       "-//Hibernate/Hibernate Mapping DTD3.0//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.bean">
    <class name="Person"table="person">
    <cacheusage="read-write" region="cn.itcast.bean.Person"/>
       <id name="id">
           <generatorclass="native"/>
       </id>
       <property name="name" length="10"not-null="true"/>
    </class>
</hibernate-mapping>

usage说明了缓存的策略，region指定缓存的区域名
Ehcache默认的配置文件ehcache.xml（放在类路径下）

<ehcache>
    <diskStorepath="D:\cache"/>
    <defaultCache maxElementsInMemory="1000“ eternal="false“ overflowToDisk="true"
       timeToIdleSeconds="120"
       timeToLiveSeconds="180"
       diskPersistent="false"
       diskExpiryThreadIntervalSeconds="60"/>
<cache name="cn.itcast.bean.Person" maxElementsInMemory="100"eternal="false"
    overflowToDisk="true"timeToIdleSeconds="300" timeToLiveSeconds="600"diskPersistent="false"/>
</ehcache>

defaultCache节点为缺省的缓存策略
maxElementsInMemory 内存中最大允许存在的对象数量
eternal 设置缓存中的对象是否永远不过期
overflowToDisk 把溢出的对象存放到硬盘上
timeToIdleSeconds指定缓存对象空闲多长时间就过期,过期的对象会被清除掉
timeToLiveSeconds 指定缓存对象总的存活时间
diskPersistent 当jvm结束是是否持久化对象
diskExpiryThreadIntervalSeconds指定专门用于清除过期对象的监听线程的轮询时间
在web容器中实例化spring容器，

<!--指定spring的配置文件，默认从web根目录寻找配置文件，我们可以通过spring提供的classpath:前缀指定从类路径下寻找-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:beans.xml</param-value>
</context-param>
<!-- 对Spring容器进行实例化 -->
<listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

在web容器中配置struts，

<servlet>
<servlet-name>struts</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>struts</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

如果action没有交给spring管理时，我们通过下面语句获取spring容器实例
WebApplicationContext ctx =WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());
把action交给spring管理后，我们可以使用依赖注入在action中注入业务层的bean。确保action的path属性值与bean的名称相同。
<action path="/person/list" ...>
</action>
Spring 配置：
<bean name="/person/list"class="cn.itcast.web.action.PersonAction"/>
在struts配置文件中添加进spring的请求控制器，该请法语控制器会先根据action的path属性值到spring容器中寻找跟该属性值同名的bean。如果寻找到即使用该bean处理用户请求
<controller>
<set-property property="processorClass"value="org.springframework.web.struts.DelegatingRequestProcessor"/>
</controller>
org.springframework.web.struts.DelegatingRequestProcessor的处理过程。
假设用户请求的路径为：/person/list.do

使用spring解决struts1.3乱码问题。

<filter>
<filter-name>encoding</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>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

使用spring解决hibernate因session关闭导致的延迟加载例外问题。

<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>/*</url-pattern>
</filter-mapping>

这里JPA的实现采用hibernate，需要使用到下面的jar文件
Hiberante核心包(8个文件)
hibernate-distribution-3.3.1.GA
---------------------------------------------
hibernate3.jar
lib\bytecode\cglib\hibernate-cglib-repack-2.1_3.jar
lib\required\*.jar
Hiberante注解包(3个文件)：hibernate-annotations-3.4.0.GA
------------------------------------------------------------------------------------
hibernate-annotations.jar
lib\ejb3-persistence.jar、hibernate-commons-annotations.jar
Hibernate针对JPA的实现包(3个文件)：hibernate-entitymanager-3.4.0.GA
------------------------------------------------------------------------------------------------------
hibernate-entitymanager.jar
lib\test\log4j.jar、slf4j-log4j12.jar
JPA规范要求在类路径的META-INF目录下放置persistence.xml，文件的名称是固定的，配置模版如下：

<?xml version="1.0"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistencehttp://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"version="1.0">
  <persistence-unit name="itcast"transaction-type="RESOURCE_LOCAL">
     <properties>
        <propertyname="hibernate.dialect"value="org.hibernate.dialect.MySQL5Dialect"/>
        <propertyname="hibernate.connection.driver_class"value="org.gjt.mm.mysql.Driver"/>
        <propertyname="hibernate.connection.username" value="root"/>
        <propertyname="hibernate.connection.password" value="123456"/>
        <propertyname="hibernate.connection.url"value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
        <propertyname="hibernate.max_fetch_depth" value="3"/>
        <propertyname="hibernate.hbm2ddl.auto" value="update"/>
     </properties>
  </persistence-unit>
</persistence>

在spring中配置EntityManagerFactory

<bean id="entityManagerFactory"class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
     <property name="persistenceUnitName" value="itcast"/>
  </bean>
  <bean id="txManager"class="org.springframework.orm.jpa.JpaTransactionManager">
  <property name="entityManagerFactory"ref="entityManagerFactory"/>
  </bean>
 <tx:annotation-driventransaction-manager="txManager"/>
使用spring解决JPA因EntityManager关闭导致的延迟加载例外问题。
<filter>
       <filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
      <filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
 </filter>
 <filter-mapping>
       <filter-name>SpringOpenEntityManagerInViewFilter</filter-name>
       <url-pattern>/*</url-pattern>
 </filter-mapping>

使用到struts2的lib目录下所有不带-plugin结尾的jar文件，但除了struts2-spring-plugin-2.0.11.1.jar
在web容器中实例化spring容器和配置struts2

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
配置struts2
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
struts2的配置文件模版struts.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache SoftwareFoundation//DTD Struts Configuration 2.0//EN"
   "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
   <!-- 该属性指定需要Struts2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts2处理。
   如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。 -->
    <constantname="struts.action.extension" value="do"/>
    <!--设置浏览器是否缓存静态内容,默认值为true(生产环境下使用),开发阶段最好关闭 -->
    <constantname="struts.serve.static.browserCache" value="false"/>
    <!--当struts的配置文件修改后,系统是否自动重新加载该文件,默认值为false(生产环境下使用),开发阶段最好打开 -->
    <constantname="struts.configuration.xml.reload" value="true"/>
    <!--开发模式下使用,这样可以打印出更详细的错误信息 -->
    <constantname="struts.devMode" value="true" />
     <!--默认的视图主题 -->
    <constantname="struts.ui.theme" value="simple" />
    <constantname="struts.objectFactory" value="spring" />
  <package name="person" namespace="/person"extends="struts-default">
  <global-results>
  <resultname="message">/WEB-INF/page/message.jsp</result>
  </global-results>
<action name="action_*" class="personList" method="{1}">
<result name="list">/WEB-INF/page/persons.jsp</result>
<result name="add">/WEB-INF/page/add_person.jsp</result>
<resultname="edit">/WEB-INF/page/edit_person.jsp</result>
</action>
    </package>
</struts>

struts2的标签

<%@ page language="java" contentType="text/html;charset=UTF-8"   pageEncoding="UTF-8"%>
<%@taglib uri="/struts-tags" prefix="s" %>
<s:hidden name="person.id"/>
姓名:<s:textfield name="person.name"/><br>
<input type="submit" value="发送"/>
<s:iterator value="persons" >
<s:property value="id"/>, <s:property value="name"/>
<a href='<s:url action="action_editUI"namespace="/person"><s:param name="person.id"value="id"/></s:url>'>修改</a>
</s:iterator>

花开不合阳春暮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring2.5(2)

AOP中的概念Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)Pointcut(切入点):所谓切入点是指我们
复制链接

扫一扫

专栏目录