`
one_way_street
  • 浏览: 1434 次
  • 性别: Icon_minigender_1
  • 来自: 北京
最近访客 更多访客>>
社区版块
存档分类
最新评论

初识 Struts2 第二节

 
阅读更多

1. 扩展列表显示示例 ( 添加分页处理 )

a.在TaskDAO中添加两个方法 

package dao;

import java.util.List;

import entity.Task;

public interface TaskDAO{
	//查处数据库中的所有数据
	public List<Task> findAll() throws Exception;
	/**
	 * 分页查询
	 * @param page 查询第几页
	 * @param pageSize 每一页最多显示几条记录
	 * @return
	 * @throws Exception
	 */
	public List<Task> findAll(int page, int pageSize) throws Exception; 
	/**
	 * 统计一共有多少页
	 * @param pageSize 每一页最多显示几条记录
	 * @return
	 * @throws Exception
	 */
	public int countTotalPage(int pageSize) throws Exception;
}

    b .在TaskDAOimpl中写方法实现 

package dao.impl;

import java.util.ArrayList;
import java.util.List;
import java.sql.*;
import util.DBUtil;
import dao.TaskDAO;
import entity.Task;

public class TaskDAOimpl implements TaskDAO{

	public List<Task> findAll() throws Exception {
		List<Task> taskList = new ArrayList<Task>();
		Connection conn = DBUtil.getConnection();
		String sql = "select * from t_task";
		PreparedStatement pstmt = conn.prepareStatement(sql);
		ResultSet rs = pstmt.executeQuery();
		while(rs.next()){
			Task task = new Task();
			task.setId(rs.getLong("id"));
			task.setTas_id(rs.getString("tas_id"));
			task.setTas_name(rs.getString("tas_name"));
			task.setTas_begin(rs.getDate("tas_begin"));
			task.setTas_end(rs.getDate("tas_end"));
			taskList.add(task);
		}
		DBUtil.close(conn);
		return taskList;
	}

	public List<Task> findAll(int page, int pageSize) throws Exception {
		List<Task> taskList = new ArrayList<Task>();
		Connection conn = DBUtil.getConnection();
		String sql = "select * from t_task limit ?,?";
		PreparedStatement pstmt = conn.prepareStatement(sql);
                //设置分页查询参数
                int begin = (page-1) * pageSize;
		pstmt.setInt(1, begin);
		pstmt.setInt(2, pageSize);
		ResultSet rs = pstmt.executeQuery();
		while(rs.next()){
			Task task = new Task();
			task.setId(rs.getLong("id"));
			task.setTas_id(rs.getString("tas_id"));
			task.setTas_name(rs.getString("tas_name"));
			task.setTas_begin(rs.getDate("tas_begin"));
			task.setTas_end(rs.getDate("tas_end"));
			taskList.add(task);
		}
		DBUtil.close(conn);
		return taskList;
	}

	public int countTotalPage(int pageSize) throws Exception {
		Connection conn = DBUtil.getConnection();
		String sql = "select count(*) from t_task";
		PreparedStatement pstmt = conn.prepareStatement(sql);
		ResultSet rs = pstmt.executeQuery();
		rs.next();
		int count = rs.getInt(1);
		DBUtil.close(conn);
                //计算最大页,如果没有数据,最大页设为1
                if(count ==0){
			return 1;
		}else if(count % pageSize == 0){
			return count/pageSize;
		}else{
			return count/pageSize + 1;
		}
	}
}

      c.修改TaskAction 添加属性方法 

package action;

import java.util.List;

import dao.impl.TaskDAOimpl;

import entity.Task;

public class TaskAction {
	private List<Task> taskList;
	//当前要显示第几页
	private int page=1; //成员变量
	//最大页
	private int totalPage;
	//每页显示3条数据
	public static final int PAGE_SIZE = 3;
	
	public String execute(){
		TaskDAOimpl dao = new TaskDAOimpl();
		try {
			//查询数据
			taskList = dao.findAll(page, PAGE_SIZE);
			//获取最大页,
			//最大页也可根据list集合获得,为了提高效率,最好使用此方法
			totalPage = dao.countTotalPage(PAGE_SIZE);
			return "success";
		} catch (Exception e) {
			e.printStackTrace();
			return "error";
		}
	}
	public List<Task> getTaskList() {
		return taskList;
	}
	public void setTaskList(List<Task> taskList) {
		this.taskList = taskList;
	}
	public int getPage() {
		return page;
	}
	public void setPage(int page) {
		this.page = page;
	}
	public int getTotalPage() {
		return totalPage;
	}
	public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}
}

        d.修改视图list.jsp 

<%@ page contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
<title>Insert title here</title>
</head>
<body>
	<table border="1">
		
		<tr>
			<th>编号</th>
			<th>任务名称</th>
			<th>开始事件</th>
			<th>结束事件</th>
		</tr>
		<c:forEach items="${taskList}" var="list">
			<tr>
				<td>${list.tas_id}</td>
				<td>${list.tas_name }</td>
				<td>${list.tas_begin }</td>
				<td>${list.tas_end }</td>
			</tr>
		</c:forEach>
	</table>
	<c:choose>
		<c:when test="${page <= 1}">
			<a>上一页</a>
		</c:when>
		<c:otherwise>
			<a href="/struts2_showlist/list?page=${page-1 }">上一页<<</a>
		</c:otherwise>
	</c:choose>
	第${page }页,共${totalPage }页
	<c:choose>
		<c:when test="${page >= totalPage}">
			<a>下一页</a>
		</c:when>
		<c:otherwise>
			<a href="/struts2_showlist/list?page=${page+1 }">下一页>></a>
		</c:otherwise>
	</c:choose>
</body>
</html>

     修改完毕,(无法上传图片,所以展示运行效果).

 

 

了解一下 Action 中成员变量和属性概念 , 一般情况下成员变量名和属性名一致 . 属性需要有对应的 setter 和 getter 方法 .

  public class A{

     private String n;// 成员变量名为 n

     // 属性名为 name

     public void setName(String name){...}

     public String getName(){...}

  }

  (1)Struts2 将请求参数值给 Action 传递时 , 属性名与请求参数名保持一致 .

  (2) 在 JSP 视图中 , 使用 EL 表达式获取 Action 数据时 , 与 属性保持一致 .

2.OGNL 技术的使用

OGNL 技术源于 ognl.jar, ognl.jar 在 webwork 框架中开始引入 , 后来在 Struts2 才延续下来 .

(1).ognl.jar 有什么作用 .

     Object Graphic Navigation Language   对象图导航语言

ognl.jar 可以便于对复杂对象的访问 , 例如属性获取和设置值 , 方法调用等 . 使用时需要编写 OGNL 表达式 . 比 EL 表达式功能强大 .

(2)OGNL 基本语法

a. 基本类型属性

   “id”, “name”

b. 数组和 List

“array[0]”, “list[1]”

c. Map

   “map.key”, “map[‘key’]”

d. 基本运算符

   +,-,*,/ 三目运算等都支持

e. 方法调用

   array[0].toLowerCase()

f. 静态方法和常量调用

   @java.lang.Math@PI

   @ 包名 . 类名 @ 常量

   @ 包名 . 类名 @ 静态方法 ()

g. 集合过滤

   集合属性 .{?#this.age>15}

              #this 可以理解成集合元素

              ? 指的是返回满足过滤条件的所有元素

              ^ 指的是返回第一个满足条件的元素

              $ 指的是返回最后一个满足条件的元素

h. List 和 Map 常量的定义

     List 常量 ”{‘tom’,’scott’}”, ”{1,2,3}”

     Map 常量 “#{‘age’:20, ‘name’:’ 张三 ’}”

代码演示

创建FOO实体类 

package entity;

import java.util.List;
import java.util.Map;

public class Foo {
	private int id;
	private String name;
	private String[] array;
	private List<String> list;
	private Map<String,String> map;
	private List<Person> pers;
	
	
	public List<Person> getPers() {
		return pers;
	}
	public void setPers(List<Person> pers) {
		this.pers = pers;
	}
	public String[] getArray() {
		return array;
	}
	public void setArray(String[] array) {
		this.array = array;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public List<String> getList() {
		return list;
	}
	public void setList(List<String> list) {
		this.list = list;
	}
	public Map<String, String> getMap() {
		return map;
	}
	public void setMap(Map<String, String> map) {
		this.map = map;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

 创建Person实体类 

package entity;

public class Person {
	private Address address;
	private int age;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}
}

 创建Address类 

package entity;

public class Address {
	private String street;
	private String zipcode;
	public Address(String street, String zipcode) {
		super();
		this.street = street;
		this.zipcode = zipcode;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String getZipcode() {
		return zipcode;
	}
	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}
}

 创建TestOgnl_01类 

package test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import ognl.Ognl;
import ognl.OgnlException;
import org.junit.Test;

import entity.Address;
import entity.Foo;
import entity.Person;

public class TestOgnl {
	@Test
      public void test1(){
    	  Foo foo = new Foo();
    	  foo.setId(100);
    	  foo.setName("张三");
    	  foo.setArray(new String[]{"A","B","C"});
    	  List<String> list = new ArrayList<String>();
    	  list.add("one");
    	  list.add("two");
    	  list.add("three");
    	  foo.setList(list);
    	  Map<String,String> map = 
    		  new HashMap<String, String>();
    	  map.put("one", "壹");
    	  map.put("two", "贰");
    	  map.put("three", "叁");
    	  foo.setMap(map);
    	  List<Person> pers = new ArrayList<Person>();
    	  Person p1 = new Person();
    	  p1.setAddress(new Address("中鼎大厦","100021"));
    	  Person p2 = new Person();
    	  p2.setAddress(new Address("CBD大街","120002"));
    	  pers.add(p1);
    	  pers.add(p2);
    	  foo.setPers(pers);
    	  //利用OGNL对foo对象访问
    	  //Ognl.getValue("OGNL表达式", foo);
    	  try {
    		  //基本类型数据的访问
			Integer id = (Integer)Ognl.getValue("id", foo);
			System.out.println(id);
			String name = (String)Ognl.getValue("name", foo);
			System.out.println(name);
			//数组访问
			String arry = (String)Ognl.getValue("array[0]",foo);
			System.out.println(arry);
			//List集合访问,表达式风格与数组一样
			Ognl.setValue("list[0]", foo, "oneone");
			String lst = (String)Ognl.getValue("list[0]",foo);
			System.out.println(lst);
			//map集合访问,map['key']或map.key
			String mp = (String)Ognl.getValue("map['three']", foo);
			System.out.println(mp);
			//访问pers集合属性值
			String val = (String)Ognl.getValue("'北三环'+pers[0].address.street", foo);
			System.out.println(val);
    	                //方法调用
			String str = (String)Ognl.getValue("array[0].toLowerCase()", foo);
			System.out.println(str);
                        //Ognl.getValue("list.size()", foo);
			//静态方法和常量访问
			Object obj = 
				Ognl.getValue("@java.lang.Math@PI", foo);
			System.out.println(obj);
    	  } catch (OgnlException e) {
			e.printStackTrace();
		}
      }
	
}

创建TestOgnl_02类 

package test;

import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import ognl.Ognl;
import ognl.OgnlException;

import entity.Address;
import entity.Foo;
import entity.Person;

public class TestOgnl_02 {
	@Test
	public void test1(){
		Foo foo = new Foo();
		List<Person> pers = new ArrayList<Person>();
		Person p1 = new Person();
		p1.setAge(18);
		p1.setAddress(new Address("中鼎大厦A","10021"));
		
		Person p2 = new Person();
		p2.setAge(13);
		p2.setAddress(new Address("中鼎大厦B","10022"));
	
		Person p3 = new Person();
		p3.setAge(20);
		p3.setAddress(new Address("中鼎大厦C","10023"));
		
		pers.add(p1);
		pers.add(p2);
		pers.add(p3);
		foo.setPers(pers);
		//集合的过滤
		try {
			List<Person> list = (List)
				Ognl.getValue("pers.{?#this.age>15}", foo);
			for(Person p : list){
				System.out.println(p.getAge() +
						p.getAddress().getStreet());
			}
			//List常量定义
			Object obj = Ognl.getValue("{1,2,3}", null);
			System.out.println(obj.getClass());
		} catch (OgnlException e) {
			e.printStackTrace();
		}
	}
}

(3)OGNL 体系结构

主要包含三个组成部分

         OGNL 引擎 : 负责解析 OGNL 表达式 , 访问目标对象 (root) 和上下文对象 (context).

         root 对象 :Object 类型 , 根对象 , 默认访问此对象

         context 对象 :map 类型 , 上下文对象 , 表达式以 # 开始时访问此对象

3.OGNL 在 Struts2 中的使用

         (1)XWork 框架对 OGNL 进行了改造

XWork 提供了一个 CompountRoot 对象 , 替换了 OGNL 原有的 Root 对象 . CompountRoot 是一个栈结构 , 可以存放多个root对象,当输入 ”name” OGNL 表达式时 , OGNL 引擎会从栈顶对象向下一次寻找属性值 , 找到返回 , 找不到返回 null.

        context对象同OGNL一样.

         (2)ValueStack 对象

         ValueStack 对象类型为 OgnlValueStack, 内部封装了 OGNL 体系结构 , 内部提供了访问和存储机制 .

         当客户端发送请求之后 , Struts 框架会自动创建一个 ValueStack, 并存入 request 中 , key 为 ”struts.valueStack”, 然后将 request, session,application 等对象存入 context 区域 , 将 Action 对象存入 root 栈顶 , 当请求完毕后 , Action 对象会清除 , 然后将下一个请求的 Action 压入 .

 

4. 使用 OGNL+Struts2 标签重构列表显示示例

修改list.jsp 

<table border="1">
		
		<tr>
			<th>编号</th>
			<th>任务名称</th>
			<th>开始事件</th>
			<th>结束事件</th>
		</tr>
		<s:iterator value="taskList" var="list">
			<tr>
				<td><s:property value="#list.tas_id"/></td>
				<td><s:property value="#list.tas_name"/></td>
				<td><s:property value="#list.tas_begin"/></td>
				<td><s:property value="#list.tas_end"/></td>
			</tr>
		</s:iterator>
	</table>
	<s:if test="page <= 1">
			<a>上一页</a>
	</s:if>
	<s:else>
			<a href="/struts2_showlist/list?page=<s:property value="page-1"/>">上一页</a>
	</s:else>
	第<s:property value="page"/>页,共<s:property value="totalPage"/>页
	<s:if test="page >= totalPage">
			<a>下一页</a>
	</s:if>
	<s:else>
			<a href="/struts2_showlist/list?page=<s:property value="page+1"/>">下一页</a>
	</s:else>

 

5. EL 表达式在 Struts2 中的使用

         EL 可以从 page,request,action,session,application 范围中取值并显示 .

         EL 为什么在 JSP 中可以访问到 Action 属性 ?

         ${name} -->

String name = request.getAttribute(“name”);

out.println(name);

Struts2 将原有的 request 对象封装了 , 并重写了 getAttribute 方法 .

 

public class StrutsRequestWrapper extends HttpServletRequestWrapper{

         public Object getAttribute(String key){

                   Object value = super.getAttribute(key);

                   if(value == null){

                         valueStack.findValue(“OGNL表达式”);

                         //Ognl.getValue(“name”, context, root);

                   }

                   return value;

         }

}
 

 

 

分享到：
初识 Struts2 第一节
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    初识 Struts2 第一节

    本节我们将初识Struts2，了解其核心概念、工作原理以及如何开始使用。 **1. Struts2 概述** Struts2是Apache软件基金会下的开源项目，它是Struts1的升级版，弥补了Struts1在功能和灵活性上的不足。Struts2提供了...

    Struts2 in action中文版

    第2章 初识Struts 2 16 2.1 声明性架构 16 2.1.1 两种配置 16 2.1.2 声明架构的两种方式 17 2.1.3 智能默认值 20 2.2 简单的HelloWorld示例 20 2.2.1 部署示例应用程序 20 2.2.2 探索HelloWorld应用程序 24 2.3 使用...

    struts2帮助文档

    “第2章：环境配置”会讲解如何设置开发环境，包括JDK、Apache Tomcat服务器、Eclipse或IntelliJ IDEA等集成开发环境的安装，以及Struts2框架的依赖库添加。这一过程对于成功运行和测试Struts2应用至关重要。 “第3...

    深入浅出Struts2(附源码)

    第2章初识Struts 14 2.1 Struts的优点 14 2.2 Struts的动作处理流程 15 2.3 拦截器 17 2.4 Struts配置文件 18 2.4.1 struts.xml文件 19 2.4.2 struts.properties文件 26 2.5 Struts应用程序示例 26 2.5.1 ...

    Struts2学习笔记

    2. **环境搭建**：（一）环境搭建.txt可能包含了安装和配置Struts2框架的基础步骤，这通常包括添加Struts2库到项目依赖、配置web.xml文件、创建第一个Struts2应用等。 3. **UploadServlet.java**：在Struts2中，...

    Struts教程大全

    "Struts 2.0入门.pdf"和"Struts快速学习指南.pdf"是针对初学者的教程，它们可能从最基础的概念开始，逐步引导读者掌握Struts 2的使用，包括环境配置、创建第一个应用、控制器的实现、视图的展示以及模型的交互等。...

    简单介绍Struts2中的拦截器的小示例

    当请求到达Action时，会先执行拦截器链上的第一个拦截器，然后是第二个，依此类推，直到最后一个拦截器。如果某个拦截器返回了非`null`的结果，那么Action将不会被执行，而是直接返回该结果。 4. **应用场景**：...

    深入浅出Struts 2 .pdf(原书扫描版) part 1

    第2章 初识Struts 14 2.1 Struts的优点 14 2.2 Struts的动作处理流程 15 2.3 拦截器 17 2.4 Struts配置文件 18 2.4.1 struts.xml文件 19 2.4.2 struts.properties文件 26 2.5 Struts应用程序示例 26 2.5.1 部署描述...

    学习JSP的Struts的第一步：登录界面

    **Struts与JSP结合学习：初识登录界面** 在Web开发中，Struts框架是一个广泛应用的MVC（Model-View-Controller）架构，它帮助开发者有效地组织和管理应用程序的结构。而JSP（JavaServer Pages）则是一种用于创建...

    STRUTS基础

    在“第08章 初识Java EE经典MVC框架Struts”的源代码中，你可以看到以下几个关键部分的实现： 1. **Action类**：每个Action类处理一个特定的用户请求，实现业务逻辑并返回结果到视图。 2. **ActionForm**：定义了...

    低清版 大型门户网站是这样炼成的.pdf

    第2章 mvc混血宠儿struts 2 33 2.1 初识mvc新秀struts 2 33 2.1.1 mvc概述 33 .2.1.2 struts 2的mvc实现 35 2.1.3 struts 2的基本组成 36 2.1.4 struts 2的常用类介绍 38 2.1.5 struts 2的业务控制器action...

    Java Web编程宝典－十年典藏版.pdf.part2(共2个)

    全书分4篇，共24章，其中，第1篇为技能学习篇，主要包括Java Web开发环境、JSP语法、JSP内置对象、Java Bean技术、Servlet技术、EL与JSTL标签库、数据库应用开发、初识Struts2基础、揭密Struts2高级技术、Hib锄劬e...

    ASP.NET编程宝典光盘源码

    全书分4篇，共24章，其中，第1篇为技能学习篇，主要包括Java Web开发环境、JSP语法、JSP内置对象、Java Bean技术、Servlet技术、EL与JSTL标签库、数据库应用开发、初识Struts2基础、揭密Struts2高级技术、Hib锄劬e...

    《ASP.NET编程宝典(十年典藏版)》光盘源码2

    全书分4篇，共24章，其中，第1篇为技能学习篇，主要包括Java Web开发环境、JSP语法、JSP内置对象、Java Bean技术、Servlet技术、EL与JSTL标签库、数据库应用开发、初识Struts2基础、揭密Struts2高级技术、Hib锄劬e...

    精通Java Web整合开发(第2版)

    第12章 基于annotation注解技术的ssh 2整合开发 12.1 初识annotation522 12.2 亲身体验annotation的威力524 12.3 struts 2.x的annotation插件convention-plugin528 12.4 hibernate 3.x的annotation解决之道532 ...

    first_steps_with_struts.zip_Java书籍_Java_

    《初识Struts：Java Web开发之旅》 在Java Web开发领域，Struts框架一直扮演着重要的角色。这个名为"first_steps_with_struts.zip"的压缩包，显然是一份关于Struts 2的教程或者书籍资源，旨在帮助开发者迈出使用...

Magicbox
Global site tag (gtag.js) - Google Analytics