标签：
JSP：页面文件，动态页面。
JSP：JAVA Server Page，是服务器端一种基于JAVA语言的网页技术，所有程序操作都是在服务端执行，网络上传送的仅仅是运行的结果。运行的结果与浏览器无关，但是发送的结果在不同浏览器展示的效果有差别。
HTML+CSS+JAVASCRIPT+JAVA+JSP标签==JSP
假如目前浏览器发送一个请求，
http://localhost:9000/project_120_0010_cookie/login.jsp。
如果是第一次向该JSP发送请求，如果页面地址不正确，将会报404错误。如果页面地址正确，那边会将该JSP转换为Servlet，然后对其进行编译。【因此第一次加载该页面会相对较慢，但是以后打开会很快。】
转换的Servlet将会对请求的信息进行响应，响应的结果为HTML文本。
JSP和Servlet区别：
唯一区别是JSP在第一次请求会编译为Servlet，其实JSP实质上就是一个Servlet。
v 静态内容
HTML文本、CSS样式、JAVASCRIPT客户端验证脚本
v 指令
指令不会再客户端产生任何的输出，是在服务器解释并执行的。最要用于对JSP页面进行转换，它只在当前页面设置有效。
<%@ page language="java" %>
<%@ 指令名称 属性=属性值 .... %>
指令名称：
Page、include、taglib[JSTL]
① Page
Page指令通常称为页面指令，可以定义在当前整个JSP页面范围的有效属性。
ü Language
当前编写JSP所使用的语句，目前只能为JAVA
ü Import
用于向当前JSP页面导入所需要的包和类名【类的路径】
格式：
import="java.util.*":表示util包下的所有类
import="java.util.*,java.a.A"：表示util包下的所有类，以及A类
默认导入包：
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;
【从Work文件夹下查找到对应的类文件。】
ü pageEncoding
用来设置JSP页面的字符编码
ü contentType
设置页面响应的MIME
|
<%@ page language="java" import="java.util.*" contentType="application/msword; charset=utf-8"%> <table> <tr> <td>123</td> <td>123</td> </tr> </table> |
ü Session
设置当前页面是否支持Session，默认是true。
ü isThreadSafe
是否线程安全，默认为true。表示会已多线程的方式处理用户请求。
如果设置为false，会阻塞其它浏览器打开页面。
ü isELIgnored
表示EL表达式是否禁止，默认为false。
ü isErrorPage
表示是否为错误页面。
ü errorPage
表示错误页面，当当前页面有错误的时候跳转到指定的错误页面。
|
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" errorPage="word.jsp"%> <% int i = 5/0 ; %>
<%@ page isErrorPage="true" language="java" import="java.util.*" pageEncoding="utf-8"%> 有错误 <%=exception.getMessage() %> 注意：如果要使用exception对象，需要设置isErrorPage为true。 |
② Include
用于页面包含。
<%@ include file="head.html" %>
其实质将两个页面合并为一个Servlet。
与动作方式的包含本质区别在于是否合并为一个Servlet。
<jsp:include page="head.html"></jsp:include>
另外包含的文件可以为HTML、JSP、文本文档等。
另外file属性对应的路径可以为绝对路径以及相对路径。
③ Tablib
后面讲述，JSTL
v 表达式
<%= %>
v 注释
<%-- --%> 该注释方式为JAVA注释方式，页面源代码看不到，展示页面看不到
<!-- 你好 -->该注释方式为HTML注释方式，页面源代码能看到，展示页面看不到
v 声明
格式：<%! int i = 6 ; %>
定义属性：
定义方法：
|
<%! int i = 6 ;
String hello(String person){ return "你好"+person; } %> <%=hello("120") %> |
v 动作
后面讲述
作业：向JSP发送请求，打印倒三角形。例如输入5，那么打印5行倒三角形。
pageContext在JSTL中使用。能找到任何的内置对象。
Page相当于this对象，反映的是当前JSP转换为Servlet的对象。
Exception需要在页面中定义了指令的属性isErrorPage属性为true。
Config获取配置信息。
|
<%=config.getServletContext().getInitParameter("as") %> |
|
<servlet> <servlet-name>test</servlet-name> <jsp-file>/sjx.jsp</jsp-file> <init-param> <param-name>ss</param-name> <param-value>123</param-value> </init-param> </servlet>
<servlet-mapping> <servlet-name>test</servlet-name> <url-pattern>/sjx1.jsp</url-pattern> </servlet-mapping> <%=config.getInitParameter("ss") %> |
JAVABEAN是一个封装了业务逻辑的可重用组件，包括可视化组件以及封装业务逻辑的组件。例如：分页
Model 1： JSP + JAVABEAN
Model 2: JSP + SERVLET + Service + Servlet + JSP 【MVC】
v JAVABEAN构造
1.构造对象
<jsp:useBean id="g" class="vo.Goods"></jsp:useBean>
|
Goods g = new Goods();
2.设置属性值
<jsp:setProperty property="name" name="g1" value="234"/>
|
g.setName("123");
3.获取属性值
<jsp:getProperty property="name" name="g1"/>
g1.getName()
4.设置参数值
|
<jsp:useBean id="g1" class="vo.Goods"></jsp:useBean> <jsp:setProperty property="name" name="g1" value="<%=request.getParameter("name") %>"/> <jsp:setProperty property="count" name="g1" value="<%=Integer.parseInt(request.getParameter("count")) %>"/> <jsp:getProperty property="name" name="g1"/> <jsp:getProperty property="count" name="g1"/> <hr/> <jsp:useBean id="g2" class="vo.Goods"></jsp:useBean> <jsp:setProperty property="name" name="g2" param="name"/> <!-- g2.setName(request.getParameter("name")) --> <jsp:setProperty property="count" name="g2" param="count"/> <jsp:getProperty property="name" name="g2"/> <jsp:getProperty property="count" name="g2"/> |
5.设置生效范围
其值：page、application、request、session
作业：
1.练习课堂上的知识
2.写一个组件，用于打印对应的SQL语句中的数据。
|
<jsp:useBean id="db" class="javabean.EmpJavaBean" scope="page" ></jsp:useBean> <jsp:setProperty property="sql" name="db" value="select * from emp" /> <% List<Emp> emps = db.getList(); out.print(emps.get(0).getEname()); %> |
|
public class EmpJavaBean {
private IEmpDao dao = new EmpDaoImpl();
private String sql ;
private List<Emp> list ;
public String getSql() { return sql; }
public void setSql(String sql) { this.sql = sql; }
public List<Emp> getList() { list = dao.listTables(sql); //访问数据库 return list; }
} |
v JAVABEAN要求
1.必须得有一个无参的构造方法
2.提供属性的接口，使用set/get方法
3.最好实现序列化接口
v 分页
|
public class Page {
private int pageNo; // 当前第几页
private int pageSize; // 每页多少条数据
private int totalPages;// 总共多少页
private int totalResults;// 总共多少记录
private int defaultPageSize = 10;
private List<?> results;// 分页之后的结果
private String pageSQL = "";// 分页的SQL语句
private String sqlCount = "";// 获取总共多少条数据
private String clazz ;
private String html;
public void setClazz(String clazz) { this.clazz = clazz; }
public String getHtml() { this.html = "<div id=\"page\" style=\"border: 1px double black;font-size: 14px;height: 22px;\">" + "<span style=\"margin: 15px\">当前第"+getPageNo() +"/"+getTotalPages() +"页 共"+getTotalResults()+"行</span> " + "<span style=\"float: right;margin-right: 20px;\">" + "<a style=\"margin-right:8px;\" href=\"page.jsp?index=1\">首页</a>" + "<a style=\"margin-right:8px;\" href=\"page.jsp?index="+(getPageNo()-1)+"\">上一页</a>" + "<a style=\"margin-right:8px;\" href=\"page.jsp?index="+(getPageNo()+1)+"\">下一页</a>" + "<a style=\"margin-right:8px;\" href=\"page.jsp?index="+getTotalPages() +"\">尾页</a>" + "</span> </div>"; return html; }
private JdbcTemplate template = new JdbcTemplate();
public int getDefaultPageSize() { return defaultPageSize; }
public Page() { super(); this.pageSize = defaultPageSize; }
public String getPageSQL() { return pageSQL; }
public void setPageSQL(String pageSQL) { this.pageSQL = pageSQL;
try { IPageDao dao = (IPageDao)Class.forName(this.clazz).newInstance(); this.results = dao.listTables(pageSQL, new Integer[] { pageNo * pageSize, (pageNo - 1) * pageSize }); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } }
public void setSqlCount(String sqlCount) { this.sqlCount = sqlCount; this.totalResults = template.queryForCount(sqlCount, null); this.totalPages = totalResults / pageSize == 0 ? 1 : (totalResults % pageSize == 0 ? totalResults / pageSize : totalResults / pageSize + 1); }
public int getPageNo() { return pageNo == 0 ? 1 : pageNo; }
public void setPageNo(int pageNo) { this.pageNo = pageNo < 1 ? 1 : (pageNo > totalPages ? totalPages : pageNo); }
public int getPageSize() { return pageSize; }
public void setPageSize(int pageSize) { this.pageSize = pageSize; }
public int getTotalPages() { return totalPages; }
public int getTotalResults() { return totalResults; }
public List<?> getResults() { return results; } } |
|
<body> <jsp:useBean id="pg" class="javabean.Page" ></jsp:useBean> <jsp:setProperty property="pageSize" name="pg" value="3"/> <jsp:setProperty property="sqlCount" name="pg" value="select count(*) from dept"/> <jsp:setProperty property="pageNo" name="pg" param="index"/> <jsp:setProperty property="clazz" name="pg" value="dao.impl.DeptDaoImpl"/> <jsp:setProperty property="pageSQL" name="pg" value="select * from (select t.*,rownum rn from dept t where rownum<=?) where rn>? "/>
<% List<Dept> emps = (List<Dept>)pg.getResults(); %> <%=emps.size() %> <div id="main"> <table> <tr>
</tr> </table> </div> <jsp:getProperty property="html" name="pg"/> </body>
注意JAVABEAN设置的先后顺序 |
转发：<jsp:forward page="t.jsp"></jsp:forward>
<jsp:forward page="t.jsp?id=1"></jsp:forward>
<jsp:forward page="t.jsp">
<jsp:param value="AB" name="id"/>
</jsp:forward>
内容合并：<jsp:include page="t.jsp"></jsp:include>
<%@ include file=”” %>
区别：
|
指令方式 |
动作方式 |
|
相当于将两个页面合并为一个Servlet |
只是内容合并，页面代码并未合并为一个Servlet |
|
两个页面共享一个request对象 |
两个页面使用两个request对象 |
|
包含页面和被包含页面字符编码必须一致 contentType="text/html; charset=utf-8" |
不要求 |
|
指令方式效率更高 |
|
|
不能传递参数值 |
可以，借助jsp：param动作 <jsp:include page="t.jsp"> <jsp:param value="1" name="id"/> </jsp:include> |
v EL表达式介绍
EL：Expression Language，表达式语言。
EL表现形式： ${ }
EL表现结构：${user.name } == <%= user.getName() %>
v EL作用范围
可以在自定义标签和JSTL中使用，另外可以在JSP或者JAVASCRIPT中使用。
v EL表达式运算符
① 算数运算符
1+1: <%=1+1 %> <br/>
1+1: ${1+1 } <br/>
1/0: ${1/0 } <br/>
0/0: ${0/0 } <br/>
ab : <%="a"+"b" %><br/>
ab : ${a+b } <br/>
ab : ${"a" }${"b" }
② 关系运算
相等：1==1 : ${1==1 } | ${1 eq 1 }
不等于：1 != 2: 1!=2 : ${1!=2 } | ${1 ne 1 }
2>1 ${2>1 } | ${2 ge 1 }
ge大于等于 gt大于
Le小于等于 lt小于
③ 逻辑运算符
${1 eq 1 and 2 lt 1 }
只有短路与，没有逻辑与。
Or：或者
Not：否
④ Empty运算符
判断是否为空，空对象或者空字符串
${empty e }打印值为true
String str="123";
pageContext.setAttribute("a",str);
${empty a }
⑤ EL隐式对象
param、paramValues、pageScope、requestScope、sessionScope、applicationScope。
Param：获取参数值 ${param.id }
|
<jsp:setProperty property="name" name="g1" value="${param.name }"/> <jsp:setProperty property="count" name="g1" value="${param.count }"/> -----------------》 request.getParameter(“count”) |
paramValues:
|
/project_120_0011_javabean/MyJsp.jsp?psw=1&psw=2 ${paramValues.psw[0] } |
pageScope:作用范围为当前页面
requestScope：作用范围为request。
|
${requestScope.aaa.ename } |
⑥ EL表达式在JAVASCRIPt中使用
alert(‘${u.empno}‘);
alert(‘<%=path %>‘);
v pageContext
${pageContext.request.requestURL }
${pageContext.request.scheme }
1.JSTL介绍
JSTL：JAVA Server Page Standard Tag Library。JSP标准标签库。
目的：实现JSP页面无JAVA脚本。
tld文件用于描述标签库的配置文件。
2.配置JSTL
① 导入JSTL的JAR包。
② 进行指令的配置
<%@ taglib prefix="" uri="" %>
其值来自于jstl JAR包中MEAT-INF下。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
3.使用
① 设置值
<c:set var="i" value="1" ></c:set>
==pageContext.setAttribute(“i”,1)
② 获取值
${i }
<c:out value="${i }"></c:out>
③ 移除值
<c:remove var="i"/>
④ 捕获异常
<c:catch var="excep">
<%int i = 5/0; %>
</c:catch>
${excep }<br/>
${excep.message }
⑤ 切割
<c:forTokens items="${str }" delims=";" var="st" >
${st }<br/>
</c:forTokens>
⑥ 数字循环
<c:forEach begin="1" end="10" step="1" var="i">
${i }
</c:forEach>
⑦ 判断
<c:if test="${empty requestScope.u }">
<c:out value="当前无记录!"></c:out>
</c:if>
⑧ IF...ELSE
<c:choose>
<c:when test="${1+1!=2}">
<c:out value="1+1!=2!"></c:out>
</c:when>
<c:otherwise>
<c:out value="1+1==2!"></c:out>
</c:otherwise>
</c:choose>
⑨ 循环遍历
<c:forEach items="${requestScope.emps}" var="emp">
<tr>
<td>${emp.ename }</td>
</tr>
</c:forEach>
⑩ 综合
|
List<Emp> emps = new ArrayList<Emp>(); Emp emp = new Emp(); emp.setEname("ABC"); Emp emp1 = new Emp(); emp1.setEname("BCD"); Emp emp2 = new Emp(); emp2.setEname("CDE");
emps.add(emp); emps.add(emp1); emps.add(emp2);
request.setAttribute("emps",emps); request.getRequestDispatcher("/jstl/jstl2.jsp") .forward(request, response); |
|
<table> <tr> <td>姓名</td> </tr> <c:choose> <c:when test="${empty requestScope.emps}"> <tr> <td>当前无记录</td> </tr> </c:when>
<c:otherwise> <c:forEach items="${requestScope.emps}" var="emp"> <tr> <td>${emp.ename }</td> </tr> </c:forEach> </c:otherwise> </c:choose> </table> |
4.Sql标签
5.格式化标签
格式化时间：
<fmt:formatDate value="<%=new Date() %>" type="date"/><br>
<fmt:formatDate value="<%=new Date() %>" type="time"/><br>
<fmt:formatDate value="<%=new Date() %>" type="both"/><br>
<fmt:formatDate value="<%=new Date() %>"
pattern="yyyy-MM-dd HH:mm:ss"/><br>
另外也可以借助timeStyle属性：
<fmt:formatDate timeStyle="full" type="both">输出全部信息
<fmt:formatDate timeStyle="short" type="time">显示上午还是下午几点几分
<fmt:formatDate timeStyle="medium" type="time">显示几点几分几秒
<fmt:formatDate timeStyle="long" type="time">显示上午还是下午几点几分几秒
<fmt:formatDate timeStyle="short" type="date">显示07-4-24
<fmt:formatDate timeStyle="medium" type="date">显示2007-4-24
<fmt:formatDate timeStyle="long" type="date">显示2007年4月24日
格式化数字：
<fmt:formatNumber value="12.23" pattern=".00000">
</fmt:formatNumber><br/>
6.函数标签
Example：${fn：contains("Hello","H")}
${fn:length("abc")} =====3
7.自定义标签
自定义标签是显示设计的，用于在JSP页面中添加功能。
目的：做类似于JSTL的标签。
步骤：
1.写标签的配置文件，tld文件
|
<taglib xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd" version="2.1">
<description>JSTL 1.1 core library</description> <display-name>JSTL core</display-name> <tlib-version>1.1</tlib-version> <short-name>my</short-name> <uri>http://www.120.com</uri>
<tag> <name>hello</name> <tag-class>tag.MyTag</tag-class> <body-content>JSP</body-content> <attribute> <name>msg</name> <required>true</required> <rtexprvalue>false</rtexprvalue> </attribute> </tag>
</taglib> |
2.写标签的实现类，继承TagSupport
|
public class MyTag extends TagSupport {
} |
3.页面引入
|
<%@ taglib prefix="my" uri="http://www.120.com" %> <my:hello msg="120"></my:hello> |
4.实现JAVA代码
setPageContext：设置page的上下文，通过PageContext可以获取request、out等对象。
setAttribute：设置tld文件中标签描述的属性。
doStartTag：标签开始处理事情
SKIP_BODY：标签内的文本忽略不输出
EVAL_BODY_INCLUDE：标签中的文本内容能输出
doEndTag：标签结束处理事情
EVAL_PAGE：继续执行页面剩下的HTML
SKIP_PAGE：跳过整个JSP页面后面的输出，后面的输出会被截断。
|
public class MyTag extends TagSupport {
private JspWriter out ;
private String msg ;
public String getMsg() { return msg; }
public void setMsg(String msg) { this.msg = msg; }
@Override public void setPageContext(PageContext pageContext) { this.out = pageContext.getOut(); }
@Override public int doStartTag() throws JspException { try { out.print("<font color=\"red\" >你好，"+msg+"</font>"); } catch (IOException e) { e.printStackTrace(); } return SKIP_BODY; }
@Override public int doEndTag() throws JspException { return EVAL_PAGE; } } |
5.告诉系统tld文件所在的位置，用于系统的加载。
|
<jsp-config> <taglib> <taglib-uri>http://www.120.com</taglib-uri> <taglib-location>/WEB-INF/myTag.tld</taglib-location> </taglib> </jsp-config> |
作业：实现多语言翻译。有一个翻译表，里面存放中英文翻译，要求提供翻译标签，提供属性值为中文，此时将打印英文的输出结果。
注意：
rtexprvalue 用于设置自定义标签是否能是否EL表达式
body-content：值为empty表示标签中不能包含文本内容
值为jsp表示标签中可以包含文本内容
SVN目的是实现代码同步，保证代码都是最新的。有历史记录控制。
版本控制：SVN、CVS。
Eclipse绑定插件： Help ---> Add/Remove Software
如何确认是否绑定：Window ---> ShowView --- 》SVN
针对高版本的MyEclipse。
C:\Program Files\Genuitec\MyEclipse 8.x Latest
\configuration\org.eclipse.equinox.simpleconfigurator
作业：
1.建立一个工程，上传到服务器
2.提供一个地址，下载到客户端
相当于将很多数据库的连接放置于数据库连接池中。这样避免每次都需要创建数据库连接。注意每次用完数据库连接，会将该数据库连接对象放置于池中。
Tomcat数据库连接池。
JNDI：JAVA命名和目录服务，就是通过地址的方式查找具体的对象。
Tomcat数据库连接池使用的是JNDI去获取Tomcat的DataSource。
注意该方式只允许在Servlet以及JSP环境下。
maxActive：20 maxIdle：10
最大连接数：
最小连接数：maxIdle：10
最大等待时间：
拿1个连接，直接从最小连接数中获取。用完之后归还数据池。
拿11个连接，直接从数据池拿10个连接，临时创建10个连接
拿21个连接，直接从数据池拿10个连接，临时创建10个连接，剩下一个等待连接归还数据池。
一段时间之后，超过最小连接数的数据库连接将销毁。
1.配置context.xml
2.配置本系统web.xml
3.将class12.jar包放置于lib文件夹下
4.代码实现。
优势：
1． 资源重用
由于数据库连接得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性（减少内存碎片以及数据库临时进程/线程的数量）。
2． 更快的系统响应速度
数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。
3． 新的资源分配手段
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接的配置，实现数据库连接池技术，几年钱也许还是个新鲜话题，对于目前的业务系统而言，如果设计中还没有考虑到连接池的应用，那么…….快在设计文档中加上这部分的内容吧。某一应用最大可用数据库连接数的限制，避免某一应用独占所有数据库资源。
4． 统一的连接管理，避免数据库连接泄漏
在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。
v 反射概念
Reflect，反射是指在程序运行时获取自身的信息【自省】。在JAVA中只需要提供类所在的路径，就可以通过反射获取类的所有信息。
v 获取类中的属性
|
public class User { protected int a;
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; } }
User u = new User(); Field[] fields = u.getClass().getFields();//获取public修饰符 for (Field field : fields) { System.out.println(field.getName());//获取属性的名称 }
Field[] fields1 = u.getClass().getDeclaredFields(); //获取类中的所有属性 for (Field field : fields1) { System.out.println(field.getName()); } |
作业：
1.获取属性的修饰符
Field.getModifiers()
Modifier.toString(field.getModifiers())
2.获取属性的返回值类型
field.getType().getName()
v 构造函数
① 无参构造函数
|
User uu = (User)Class.forName(path).newInstance(); uu.setUsername("123"); System.out.println(uu.getUsername()); |
② 有参的构造函数
|
Constructor<User>[] construs = (Constructor<User>[]) Class.forName(path).getConstructors(); //获取类的构造函数 System.out.println(construs.length);//获取类中有几个构造函数 for (Constructor<User> constructor : construs) { int length = constructor.getParameterTypes().length; //获取构造函数中有几个参数 if(length == 2){ User user = constructor.newInstance("120","123456"); //调用构造函数，并给构造函数填充值 System.out.println(user.getUsername()); } } |
③ 获取父类或父接口
Class.forName(path).getSuperclass()：父类继承
Class.forName(path).getInterfaces()：父类实现
④ 调用方法
1.动态地给方法注入值
|
Method method = Class.forName(path).getMethod("setUsername", java.lang.String.class); User u =(User)Class.forName(path).newInstance(); method.invoke(u, "1111");//u.setUsername("1111") System.out.println(u.getUsername()); |
2.返回值
|
Method method1 = Class.forName(path).getMethod("test", java.lang.String.class,java.lang.Integer.class); String value = (String)method1.invoke(u, "hello",1); System.out.println(value); |
作业：
利用上述知识，做Hibernate的模拟
最终效果：
insert into country (id,contry) values(‘1‘,‘中国‘)
Hibernate配置文件如下：
Insert into country (id,name) values(getId(),getCountry())
<hibernate-mapping >
<class name="com.csu.edu.pojo.Country"
table="country" dynamic-update="true" >
<id name="id" column="id">
<generator class="sequence">
<param name="sequence">sales</param>
</generator>
</id>
<property name="contry" column="name"></property>
<property name="asd" column="name"></property>
</class>
</hibernate-mapping>
Insert into country (id,name) values(getId(),getCountry())
要求：不要求配置配置文件，只需要将该配置文件用java语言模拟，将其可设置为：
tableName="saless";
map.put("id", "id");
map.put("name", "contry");
注意：hashMap中第一个字符为数据库对应的字段，第二个字符为pojo中对应的字段。
|
public class Session {
private Map<String, String> map;
private String table;
public Session() { this.table = "country"; map = new HashMap<String, String>(); map.put("id", "id"); map.put("name", "contry");// 第一个字段为列名 第二个字段为类中属性 map.put("sd", "loc"); }
public void add(Object o) { // insert into country (id,name) values(getId(),getCountry()) String sql = "insert into " + this.table + "("; Set<String> keys = map.keySet(); String columnStr = ""; String valueStr = ""; String param = ""; for (String key : keys) { columnStr += key+","; param = map.get(key); String methodName = "get"+ param.substring(0, 1).toUpperCase()+param.substring(1); try { Method method = o.getClass().getMethod(methodName); String value = (String)method.invoke(o); valueStr += value+","; } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); }
} sql += columnStr.substring(0,columnStr.length()-1) +") values("+valueStr.substring(0,valueStr.length()-1)+")"; System.out.println(sql);
} } |
1.为什么使用框架
2.Struts1框架搭建
① 建立WEB工程
② 修改web.xml
③ 拷贝struts-config.xml
④ 写Action实现
|
public class InputAction extends Action{
@Override public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { String username = request.getParameter("username");
if(username.equals("120")){ return mapping.findForward("success"); }else{ return mapping.findForward("error"); } } } |
⑤
A.do
3.自定义框架
目的：模拟Struts1框架，属于自己的框架，功能可以自己扩展。
1.建立XML文档，放置于CLASSPATH下
2.建立Schema文件，用于对XML文件进行验证
3.将XML文档转换为JAVA对象
4.将XML文档进行解析，并将数据填充到JAVA对象中
5.服务器启动时加载配置文件并转换为JAVA对象，在Web.xml文件中配置
作业：
1.登录界面，利用自定义框架。界面、FormBean、Action
2.在现有框架基础上添加方法控制功能，因为目前的处理方式基本是一个请求，对应一个Action。那么能不能扩展功能实现一个Action可以处理多个请求，一个请求代表一个方法，避免Action类过多。
3.团队合作。在团队开发过程中，由于需要用到SVN版本控制工具，那么对配置文件的修改频率过高，因此很可能存在覆盖现象。有什么方式解决。
标签：
原文地址：http://www.cnblogs.com/984187775blog/p/5153061.html
