Spring完全学习文档(ssh框架)

IOC和AOP
1.搭建spring:(1)添加jar包(2)设置配置文件(3)
2.获取配置文件:
  AplicationContext apct=new ClassPathXmlApplicationContext("bean.xml");
  service=apct.getBean("获取一个bean");

IOC配置和应用
一,xml配置
1.注入方式
  (1)setter   @Resource
  (2)构造方法注入
  (3)结构注入
  Xml:<bean id="需要注入的名称(name)" class="">
     </bean>
     <bean id="" class="">
         <property name="名称" ref="引用名称"/>
         <constructor-arg>//构造方法的注入
             <ref bean="引用注入的名称(name)"/>
         </constructor-arg>
     </bean>
2.bean的scope:singleton(单例,一直都是一个对象),prototype(每声明一次将获取不同的对象),request,session,global session
3.集合注入:
  参考相关文档//set,list,map 的注入
  <property name="set">
     <set>
       <value></value>
       <value></value>
      </set>
  </property>
4.简单属性注入:<property name="属性名" value="值"/> 
5.自动装配:
  (1)在<bean标签上 autowire="(byName,byType….)"  默认按byName(按名字装配) byType(按类型来装配,如果同一类型有两个时将报错)
  (2)在beans标签上 default-autowire="byName"  指定全局的默认装配方式
6.生命周期
  <bean  lizy-init="true"  表示在用到时才会初始化该bean,而在启动服务器时并不进行初始化()
  <bean init-method="初始化加载的方法" destroy-method="结束的方法"

二,Annotation配置
1.修改bean.xml配置文件加入xmlns命名空间和<context:annotation-config/>
2.自动装配: 在相应的属性上注解 @Autowired  @Qualifier(name="指定bean.xml中的bean的id")
  example:
 (1) @Autowried
  public void setName(@Qualifier("name")String name){
  }
  @Required  //表示必须要写的方法,在初始化时将检查该项
  (2) @Resource(name="注入名") //重要
      在配置文件中设置:
      <context:component-scan base-package="指定需要查询的包"/> //使用该项将自动在包下面去查找
      在需要注入的类中注解:@Component(value="注入名")
      (还存在其他的注解:@Repostory,@Service,@Cntroller)
3.生命周期
  @Scope("prototype/singleton")  //生存范围
  构造完成之后:@PostConstruct  相当于xml中的init-method,指加载该类时执行的方法
  @PreDestroy 容器销毁之前执行的方法,相当于xml中的destroy-method.

面向切面编程(AOP)
一,Annotation配置AOP
1.添加日志逻辑

2.添加xmlns命名空间,在添加配置<aop:aspectj-autoproxy/>  //使用aspectj注解
  (aspectj是一个专门用来产生代理(面向AOP)的框架)
 
  在切面类上配置注解 @Aspect @Component, 在方法上配置 @Before(植入点语法)
  植入点语法:
  例子:execution(public void cn.bywei.dao.impl.UserDaoImpl.save(cn.bywei.model.User))
       execution(* cn.bywei.dao.impl.*.*(*))
  JoinPoint  连接点
  PointCut  
  Aspect   切面
  Advice   切面上的逻辑(@before,@after),加在切入点上的建议
  Target  被代理的对象,把我们的逻辑植入的对象
  Weave   植入
   (1)@Pointcut("execution(* cn.bywei.dao.impl.*.*(*))")
      public void myMethod(){};
      @Before("myMethod()")
   (2)@After    //
   (3)@AfterThrowing  //当抛异常时
   (4)@Around("myMethod()")
      public void around(ProceedingJoinPoint pjp){
        pjp.proceed();
      }
二,xml配置AOP

 

数据源配置
1.dpcp 
  (1)直接在文件中配置数据库连接信息dbcp.BasicDataSource
  (2)配置一个
      <bean class="***.PropertyPlaceholderConfigurer">//通过占位符配置
        <property name="locations">
              <value>classpath:jdbc.properties</value>
       </property>
      </bean>
   dataSource中通过占位符来配置读取 jdbc.properties文件中的信息.
2.c3p0
3.proxool

Spring和Hibernate整合
1.建立SessionFactory
  在 LocalSessionFactoryBean中不支持Annotation
  而 可以使用 AnnotationSessionFactoryBean 来支持Annotation
  <property name="dataSource" ref="dataSource"/> //注入属性
 
  //配置需要注解的实体类
  (1)<property name="annotatedClasses">
       <list>
         <value>cn.bywei.model.User</value>
       </list>
   </property>

  (2)自动扫描包下面的实体类
    <property name="packageToScan">
       <list>
         <value>cn.bywei.model</value>
       </list>
    </property>
 
  //指定Hibernate的配置信息
  <property name="hibernateProperties">
     <props>
        <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
        <prop key="hibernate.show_sql">true</prop>
     </props
  </property>
2.aop主要使用在声明式事务管理
  Annotation:
  (1)在xml配置文件中添加命名空间
     添加事务管理 <tx:annotation-driven transaction-manager="txManager"/>
     添加<bean id="txManager" class="*****.HibernateTransactionManager">
                 <property name="sessionFactory" ref="sessionFactory"/>
         </bean>
     在一个方法上加事务:@Transactional
   Xml:
   

3.HibernateTemplate
  <bean id=
"hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
     <property name="sessionFactory" ref="sessionFactory"/>
  </bean>
  使用:
   hibernateTemplate.save(User);
   hibernateTemplate封装了一系列的方法.
   callback() –回调
4.
  @Component
  public class SuerDao extends HibernateDaoSupport {
     @Resource("sessionFactory")
     public void setSuperSessionFactory(SessionFactory sessionFactory){
       super.setSessionFactory(sessionFactory);
     }
  }
  this.getHibernateTemplate().save(实体类);

5.初始化bean
  配置
  <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  引入配置文件:
   <contenxt-param>
      <param-name>contextconfig</param-name>
      <param-value>claspah:beans.xml</param-value>
  </context-param>
6.使用load时,配置把session打开到视图层
  <filter>
     <filter-name>openSessionInView</filter-name>
     <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInView</filter-class>
  </filter>
  <filter-mapping>
************</*****

7.中文问题
  <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter>
        <init-param>
              <param-name>encoding</param-name>
              <param-value>GBK</param-value>
        </init-param>
  </filter>
  <filter-mapping**************
********</***********

本文由 程序员百味 http://www.bywei.cn/blog 编写

 

Hibernate完全学习文档(ssh框架)

1.Hibernate引用jar文件,建立hibernate.cfg.xml,并配置好改文件.
2.方言:<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
3.使用xml建立Hello world!
(1)xml配置映射实体类:(Class.hbm.xml)
  <class name="Class">
    <id name="id"></id>  <!–主键–>
    <property name="age"></property> <!–属性–>
  </class>
(2)在hibernate.cfg.xml中配置:<mapping resource="cn/bywei/model/Class.hbm.xml"/>
(3)使用Session
   Configuration cfg=new Configuration();
   SessionFactory cf=cfg.configure().buildSessionFactory();
   Session session=sf.openSession();
   session.beginTransaction();  
   session.save(model);
   session.getTransaction().commit();
   session.close();
   sf.close();

4.使用Annotation建立HelloWorld!
jpa:javax.persistence.Entity;(JPA是一套非常好的标准)
(1)建立一个Model类,使用注解 @Entity标识实体类   @Id 标识主键 @GenertedValue 标识自动增长列
(2)在hibernate.cfg.xml中配置:<mapping resource="cn.bywei.model.Class"/>
(3)使用Session:
  Configuration cfg=new AnnotationConfiguration();
  SessionFactory sf=cfg.configure().buildSessionFactory();
  Session session=sf.openSession();
  session.beginTransaction();
  session.save(Model);
  session.getTransaction().commit();
  session.close();
  sf.close();
———小技巧———-
1.使用注解@提示:设置 content Assist

————————-
5.O/R Mapping 面对对象的操作

Hibernate.cfg.xml基础配置
1.<property name="hbm2ddl.auto" >create/update/create-drop/validate</property>自动创建表
2.显示sql语句<property name="show_sql">true</property>
3.格式化sql语句<property name="format_sql">true</property>
———小技巧———-
1.搭建日志环境slfj logfj
2.搭建测试环境 @Test 标识测试方法 @BeforeClass执行前调用的方法@AfterClass
————————-
4.Annotation:在Model中指定实体类所对应的数据库Table:@Table(name="tableName")
  Xml:<class name="table" table=""…….
5.字段名和属性名不同时:Annotation:@Column(name="columnName")
6.指定不可存储到数据库中的属性:Aannotation:@Transient
7.格式化日期精度 @Temporal(TemporalType.DATE) 可以把日期或者日期和时间存储到数据库中
8.映射枚举类型:
  public enum Title{
     A,B,C
  }
  private Title title;

  @Enumerated(EnumType,STRING)    //枚举
  public Title getTitle(){
     ******
  }
9.ID的生成策略
  xml:<id name="id">
          <generator class="uuid"></generator>  //class=uuid 标识 字符 native 设置(sqlserver)自动增长列,squence (Oracle中标识列),auto_increamt(mysql)

      </id>
  Annotation:@generatedValue auto(相当于xml中的active)
             当不使用Oracle时,可以设置@GeneratedValue(startegy=GenerationType.IDENTITY)  设置id的生成策略(sqlerver,mysql)
  @sequenceGenerator(name="标识名字",sequenceName="数据库中的sequence名字") 指定Oracle生成的sequence名字
  @TableGenerator 生成主键策略
  @TableGenerator(
   name="",
   table="GENERATOR_TABLE",
   pkColumnName="key",
   valueColumnNamne="",
   pkClumnValue="",
   allocationSize=1
  )
10.联合主键(id,name)作为联合主键
   在类中:
   public class pk implements Serializable{
     private int id;
     private String name;
   }
   //@Override equals 和hashcode
   //关系到虚拟内存所以需要序列化
   //为了判断id 和name和传递过来的是相等的,所以需要@Override equals
   public class lianhe{
     private pk pk;
   }
(1)xml中配置:
   <composite-id name="pk" class="****">
       <key-property name=""/>
       <key-property name=""/>
   </composite-id>
(2)Annotation的配置:
  -把主键类(pk)注解为@Embeddable,并且把主键的属性注解为@Id
    -把主键的属性注解为@EmbeddedId  表示嵌入的主键id
    -直接在Entity上注解@IdClass(PK.class) 并在主键id,name上注解@Id

核心开发接口
1.读取配置:
  SessionFactory sf=new AnnotationConfiguration().configure("hibernate.cfg.xml").buildSessionFactory();
  Session session=sf.getCurrentSession(); //从上下文(在配置文件中设置current_session_context_class–取值:jta,thread,managed,custom.Class)查找,如果有就获取Session,没有就创建新的Session.
  //-用于事务的边界  -事务提交时自动Close
  //Session session=sf.openSession();//永远是创建一个新Session
  session.beginTransaction();
  session.save(Entity);
  session.getTransaction().commit();
2.对象的三种状态
  (1)Transient  刚刚new出来,内存中有对象,但无id
  (2)Persistent  内存中有id,在于Session中,数据库中也存在id
  (3)Detached   Session已经Close没有了Id,数据库中存在id
3.Hibernate的CRUD
  (1)save()  对象的三种状态
  (2)delete()
  (3)load() 和 get() 
     -load() 生成一个对象代理,需要用到的时候才会调用,
     -get() 直接读取数据
  (4)update()  //设置部分字段不更新@Column(updatable=false)
  (5)saveOrUpdate()
  (6)clear() 清除Session
  (7)flush() 让缓存与数据同步  session.setFlushMode(FlushMode.COMMIT)设置flush的同步时间
4.自动建表
  (1)使用hibernate.cfg.xml中的配置自动建表
  (2)使用程序控制:new SchemaExport(new AnnotationConfiguration().configure()).create(显示sql-true/false,是否执行到数据库-true/false);

关系映射:
1.一对一
  a)单向 一对一单向外键关联:在一方设置另一方的引用(数据库表中设置为外键关联)
         Annotation: 在引用上注解:@OneToOne  @JoinColumn(name="pk_id")设置引用的外键id名称
         xml:<many-to-one name=""  column="" unique="true"/>
         一对一单向主键关联:
         Annotation:在引用上设置@PramaryKeyJoinColumn(hibernate3.2好像有点小bug)
         xml:****
  b)双向 一对一双向外键关联:在两方都有对方的引用,双方都设置:@OneToOn
e,其中一方还需设置@OneToOne(mappedBy="另一方的引用名称")
         一对一双向主键关联:@OneToOne @PrimaryKeyJoinColumn
         xml:****
  c)联合主键:@JoinColumns
  d)组件映射:在数据库中配置为一张表,把一方设置为另一方的一部分,在引用上设置:@Embedded (表示作为这张表的一部分嵌入到)
2.一对多 多对一
  a)多对一的单向:
    Annotation:多指向一(@ManyToOne)
    xml:<many-to-one name="属性名" column="生成的外键关系名"/>
  b)多对一的双向:
    Annotation:在多指向一设置@ManyToOne,在一指向多设置@OneToMany(mappedBy="多的一方的关系名称")
    xml:一<one-to-many class="" column="和多的一致"/> 多<many-to-one name="" column="和一的一致"/>
3.多对多
  a)多对多的单向关联
    private Set<**> **=new HashSet<**>();//设置对方的引用
    Annotation:一方@ManyToMany  @JoinTable(name="中间表名",joinColumns={@JoinColumn(name="对应自己的表的关系名称")}inverseJoinColumns={,@JoinColumn(name="另外一张表的关系名称")}) 
    xml:一方
        <set name="属性名" table="数据库中间表名" >
            <key column="指向自己的表的关系名"/>
        <many-to-many class="" column="指向另外一张表的关系名"/>
        </set>
  b)多对多的双向关联
    private Set<**> **=new HashSet<**>();
    //做好单向关联后
    Annotation:使用注解@ManyToMany(mapedBy="另外一类(多)中的引用名称")
    xml:在另一方设置<many-to-many class="" column=""/>

4.关联关系中的CRUD
(1)保存时注意关联
   使用Annotation设置级联操作:在指向另一类的@关系上设置(cascade={casadeType.ALL})//表示对所有的CRUD都进行级联操作
   在双向关系中需要设置好双向关联
(2)加载数据  fetch主要影响get/load
   (cascade={casadeType.ALL},fetch=FetchType.EAGER) //FetchType取值(EAGER,LAZY)
(3)更新数据时 先做load,再设值
(4)删除数据时 注意casade的设置问题,建议使EJB QL,HQL

5.集合映射(了解)
  Set  参考多对多关系映射中(常用)
  List 雷同Set(指定排序时@OrderBy("默认Id 或者 属性 asc/desc"))
  Map  在设置Set的基础上设置@MapKey(name="map中使用哪个字段作为key") 
  //里面不能装载基础类型

6.继承映射(了解)
  (1)设计为一张表(父类和子类放在一张表中,使用一个标识列标识是哪个对象(type))
  (2)设计为多张表(父类一张,子类设计为分表)
  (3)设计一张共有的属性,子类保存特有属性
  //实现方式可以查找

7.树状映射(重要)
  实体类设计:(parent表示父项)
  id,name,Set<parent>,parent
  在parent上@ManyToOne @JoinColumn(name="parent_id")
  在Set上@OneToMany(mappedBy="parent")
  –树状结构的打印

查询语言: NativeSQL(本地的sql语言)>HQL(hibernate query language)>EJB QL(JP QL 1.0)>QBC(Query By Cretira)>QBE(Query By Example)
HQL和EJB QL
 session.createQuery("查询语句");
 注明:category
1.from 类名
2.select distinct  from 类名
3.from 类名 where id >:min and  id<max
  Query.setInteger("min",2);
  Query.setInteger("max",2);
  Query.setParameter("max",3);
  Query.setMaxResults(4);   //最大结果集
  Query.setFirstResult(1);  //读取的起点
  Query.uniqueResult();
4.导航
  from topic t where t.category.id=1
  join  // 联合查询
      select t.tilte,c.name from topic t join t.category c
  is not null  //不为空
  is empty    //为空
  like ‘%_’   //模糊查询
 
5.函数
 
  lower()
  upper()
  trim()
  concat()
  length()
  (不常用)
  abs()
  sqrt()
  mod()
6.current_date 当前日期 current_time 当前时间 current_timestamp 当前日期和时间
7.查询
  count()
  group by 
  having
  avg()
  all()
  exists() / not exists()  //能用这个时就用这个
  in()  / not in()

8.session.getNameQuery("");

9.NativeQuery
  SQLQuery q=session.createSQLQuery("本地sql语句").addEntity(类名.class);
10.QBE
  Criteria c=session.createCriteria(类名.class).add(Restrictions.约束属性);

Hibernate 性能优化
1.session.clear() 分页时需要注意使用,打开了链接需要关闭
  内存泄露,java语法上没有,而当加载许多的session时就会出现内存泄露
3.1+N问题(当取一张关联了其他表的数据时,将会加载其他的数据引发许多的sql语句)
  取关联对象的值,将引发获取被关联的对象的值,这就是1+N问题
  (1)@ManyToOne(fetch=FetchType.Lazy)  //其他的被关联的对象语句将会在需要时发出
  (2)@BatchSize(size=5)  //只取五条数据,注解添加到被关联的对象上面 
  (3)join fetch: session.createQuery("from Topic t left join fetch t.category c");
             //使用了外连接,只发一条sql语句
4.list和iterator的区别
 (1)iterator 先取id再取对象,重复使用时,先查找缓存,再查找数据库.
 (2)list  获取所有,不会查找seesion,但会先保存到session中去
5.二级缓存和查询缓存(查询的是一样的数据)
 一级缓存:session级别的缓存
 二级缓存:sessionFactory级别的缓存
 
 load默认使用二级缓存,iterator默认使用二级缓存
 list默认往二级缓存加数据,但查询时不先查询二级缓存
 二级缓存需要在配置文件中打开
 缓存算法: lru,lfu,fifo
6.事务并发处理
  a)acid
  b)事务的隔离级别
 

本文由 程序员百味 http://www.bywei.cn/blog 编写

 

struts2完全学习文档

编译问题:
java(jdk)编译设置:window-per**-java-instelled jar
java Compiler 编译设置与jdk的配置一样
Tomcat 使用的jdk与编译设置的jdk也应该是一致的

Acion的配置:
1.Struts的开发模式设置<constant name="struts.devMode" value="true"/>
2.Struts中web.xml的配置文件的设置:<filter>…</filter><filter-mapping>…</filter-mapping>
3.为jar文件建立源文件doc时,按f1可以导航到相关的文档
4.为配置文件设置提示 为 xml catalog 配置相关的dtd文件。
5.运行机制:客户端-tomcat-web.xml-filter-filter class-action-result
6.Namespace:
   (1)’/’->/index.action
   (2)’/**’ ->/**/index.action
   (3)’/**/**’ ->/**/**/index.action
   为对应的模块名。
  namespace 不写,将默认接受所有的action
  result若没有写名字,将默认为’success’.
  extends:
    从另外一个包来继承,声明一个主要配置,然后所有的都继承该包.
7.action返回:当struts.xml中没有调用方法时,默认调用execute()方法。
  struts.xml中的action中没有class是默认调用ActionSupport的execute();
  Action中有默认常量:SUCCESS ERROR INPUT等。
  可以继承implements Action / extends ActionSupport
8.Action方法调用:
  (1)struts.xml中的action的属性指定 method="方法名"
  (2)struts.xml中的action不配置属性method,而在url中使用 ‘!方法名’(dmi动态方法调用)来动态调用。
9.通配符的配置:
  使用“*”代表所有字符,使用“{1开始的数字调用第几个*}”
  使用法则:约定优于配置(提前把文件名约定好)
10.action接收参数三种方法:
  (1)(常用)通过Action属性来接收参数,属性必须写getter/setter方法。属性自动转换类型。调用时:url?属性=值&属性=值
  (2)(常用)通过DomainModel(域模型)接收参数,使用Model生成getter/setter,调用时:url?model.属性=值&model.属性=值
     –(上)通过Dto(数据传输对象)接收参数,使用同DomainModel
  (3)通过ModelDriven接收参数,在Action中 implements ModelDriven<Model>,然后又在Action中new 一个Model(必须自己new Model()),最后再继承 getModel()方法。
11.中文问题解决:
  struts.xml中使用i18n配置,<constant name="struts.i18n.encoding" value="字符编码"/>  –i18n internationalization 
  配置文件参考:struts-core.jar/org.apache.struts2/default.properties
12.简单数据校验
   在action中配置一个逻辑 然后调用 this.addFieldError("属性","错误信息");在Struts配置错误返回页面。
   页面使用struts标签<s:fielderror fieldName="属性名" theme="simple"/>
   打印错误信息:<s:property value="errors.name[0]"/> 错误信息保存在一个数组中。
   <s:debut></s:debug>显示调试信息
13.Action访问web元素 request,session,application,HttpRequest,HttpSession
   (1)request=(Map)ActionContext.getContext().get("request");
   session=ActionContext.getContext().getSession();
   application=ActionContext.getContext().getApplication();
    Action赋值:
   request.put("属性","值");
   session.put("属性","值");
   application.put("属性","值");
   jsp取值:
    <s:property value="#request.属性"/>
   (2)(常用)Action implements RequestAware,SessionAware,ApplicationAware (这也是IOC/DI的实现),定义Map<String,String> request session 和application.
   (3)在Action中定义
      private HttpServletRequest request;
      private HttpSession session;
      private ServletContext;
   Action取值:
      request= ServletActionContext.getRequest();
      session=request.getSession();
      application=session.getServletContext();             
   (4)Action implements ServletRequestAware
      private HttpServletRequest request;
      @override
      setServletRequest(**){request=request;session=request.getSession();}
14.模块包含
   <include file="其他的xml路径"/>
15.默认Action
   <default-action-ref name="默认Action名"/>

Result的配置:
1.类型type:
  (1)dispatcher 服务器端跳转到视图
  (2)redirect 客户端跳转
  (3)chain 服务器端跳转到Action和视图,<result type="chain">Action前面不要加"/",有参数param(actionName,namespace)两个属性(跳转到其他包)</result>;
  (4)RedirectAction跳转到其他Action, 地址栏显示跳转后的Action地址
2.全局结果集
  <global-results>
        <result name="全局返回类型">/other.jsp</result>
  </global-results>
3.向结果集传递参数
  (1)url?type=typeValue
  (2)Action中声名该属性type
  (3)result中取值<result>/url?type=${type}</result>
  (4)jsp页面取值:<s:property value="#parameters.type"/>O

本文由 程序员百味 http://www.bywei.cn/blog 编写

OGNL(对象Graph导航语言)表达式和struts标签(Action中演示变量:name属性,model实体类)
——->OGNL表达式
1.<s:property value="值棧中的属性名(name)"/>
2.<s:property value="model.name"/>
3.<s:property value="model1.model2.name"/>
4.<s:property value="name.length()"/> 调用普通方法
5.<s:property value="model.method()"/>调用普通方法
6.<s:property value="method()"/>调用普通方法
7.struts.xml配置:<constant name="struts.ognl.allowStaticMethodAccess" value="true"/>
  <s:property value="@cn.bywei.struts2.ognl.Class@staticMethod()"/> 访问值棧中的静态方法
  <s:property value="@cn.bywei.struts2.ognl.Class@name"/> 访问值棧中的静态属性
8.<s:property value="new cn.bywei.strus2.ognl.Class()"/>调用构造方法
9.访问集合:
  (1)<s:property value="List"/> 访问所有
     <s:property value="List[index]"/> 访问index的属性集合
     <s:property value="List{name}[index]"/> 访问属性集合中的一个
  (2)<s:property value="Set"/>
  (3)<s:property value="Map"/>
     <s:property value="Map[‘key’]"/>  /   <s:property value="Map[\"key\"]"/>
     <s:property value="Map.keys"/>  <s:property value="Map.values"/>
     <s:property value=&quot
;Map.size()"/>
10.过滤(投影)
<s:property value="model.{?#this.age==1}.{age}"/> age=q的model, this指定拿到的当前对象
<s:property value="model.{^#this.age>1}.{age}"/> age>1的开头的那个
<s:property value="model.{$#this.age>1}.{age}"/> age>1的结尾的那个
11.通过盏值访问
<s:property value="[index].name"/> 代表盏值中的index个对象的属性name
——–>struts2标签
12.<s:property value="值" default="默认值" escape="html标签格式化(true/false)"/>
   从request取值:<s:property value="#request.name"/>
   从Action中取值:<s:property value="#name"/>
13.<s:set value="值" var="变量" scope="默认为Action.(application,session,request,page,action)"/>
14.<s:bean name="类路径" var="变量">
        <s:param name="类中的属性" value="’设定新值’"/>
   </s:bean>
15.(少用)<s:include value="被包含的文件"/> 包含静态英文文件
   <s:set var="incpage" value="’/include.html’"/>
   <s:include value="%{#incpage}"/>
16.<s:fielderror fieldName="fielderror.text" theme="simple"/>
   其中的tehme设置:(1)css样式表解决 (2)xhtml解决(->struts-core.jar/template/fielderror.ftl –>struts.xml中配置:<constant name="struts.ui.theme" value="自定义的theme"/>)
17.<s:if test="表达式">
     <s:elseif test="表达式"></s:elseif>
     <s:else></s:else>
   </s:if>
18.<s:iterator value="集合可自定义map:#{1:’value1′,2:’value2′}" var="变量" status="status(count,index,even(偶数),odd(奇数),first,last)"
19.UI标签(操作复杂,与javaScript结合困难,所以不常用)
   theme 主题标签

异常处理
1.try{}catch()finally{}  
2.声明式异常.通过throws()把异常往上抛,交给Struts2来处理
  –>struts.xml中配置:
     <result…../>
       <exception-mapping result="error" exception="java.sql.SQLException(异常类型)"/>
       <result name="error">/error.jsp</result>
3.全局异常映射
  –>struts.xml中配置:
   <global-results>
      <result name="errot" >/error.jsp</result>
   </global-results>
   <global-exceptiong-mappings>
       <exception-mapping result="error" exception="java.lang.Exception(错误类型)"></exception-mapping>
   </global-exception-mappings>

国际化
1.Local 获取本地信息,ResourceBundle 绑定本地properties文件
  建立message_zh_CN.properties
2.struts国际化
  (1)类级别properties文件必须和对应的类名相同(Class_zh_CN.properties)
     包级别properties文件在包下
     全局properties,必须在struts.xml中配置:<constant name="struts.custom.i18n.resources" value="配置文件名"/>
  (2)jsp页面获取:<s:property value="getText(‘配置文件对应的key’)"/>
  (3)传递参数动态显示:
     –在properties文件中配置{0}占位符
     –jsp页面获取:
       <s:text name="配置文件中的key">
           <s:param value="值"/>
       </s:text>
动态语言切换:使用连接<a href=?request_loale=zh_CN >中文</a>

控制重复提交
1.在form表单中设置method="post"
2.在表单中设置<s:token></s:token>  token-令牌
  struts.xml 中配置:
      <interceptor-ref name="defaultStack"/>
      <interceptor-ref name="token"/>
      <result name="invalid.token">/errot.jsp</result>
类型转换
1.Action默认已经做了类型转换
2.日期转换:<s:date name="名字" format="yyy/MM/dd HH:mm:ss"/>
3.其他类型的转换,如:list,set,map以及自定义的类型转换少用

本文由 程序员百味 http://www.bywei.cn/blog 编写