JSP

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JSP相关的知识，希望对你有一定的参考价值。

一、JSP介绍

JSP：页面文件，动态页面。

JSP：JAVA Server Page，是服务器端一种基于JAVA语言的网页技术，所有程序操作都是在服务端执行，网络上传送的仅仅是运行的结果。运行的结果与浏览器无关，但是发送的结果在不同浏览器展示的效果有差别。

html+CSS+javascript+JAVA+JSP标签==JSP

二、JSP原理

假如目前浏览器发送一个请求，

http://localhost:9000/project_120_0010_cookie/login.jsp。

如果是第一次向该JSP发送请求，如果页面地址不正确，将会报404错误。如果页面地址正确，那边会将该JSP转换为Servlet，然后对其进行编译。【因此第一次加载该页面会相对较慢，但是以后打开会很快。】

转换的Servlet将会对请求的信息进行响应，响应的结果为HTML文本。

 

JSP和Servlet区别：

唯一区别是JSP在第一次请求会编译为Servlet，其实JSP实质上就是一个Servlet。

三、JSP页面构成

 

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行倒三角形。

四、JSP内置对象

 

 

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") %>

 

五、JSP动作JAVABEAN

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其它动作

转发：<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>

 

七、EL表达式

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 }

 

八、JSP标签JSTL

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.函数标签

  • fn：contains判断在某一字符串中是否包含指定的子字符串

Example：${fn：contains("Hello","H")}

  • fn：containsIgnoreCase依上，只是不再区分大小写
  • fn：startsWith是否已某字符串开头
  • fn：endsWith
  • fn:indexOf判断子字符串在原字符串中出现的位置
  • fn：split用于将一个字符串分割
  • fn：join已某字符连接
  • fn：replace使用新字符串替换原有字符串中的某一段子字符串
  • fn：trim
  • fn：substring用于从原有字符串截取一个子字符串
  • fn：substringAfter获取截取指定字符串之后的所有字符
  • fn：substringBefore与上相反
  • fn：toUpperCase将所有字母转为大写
  • fn：length

 

${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目的是实现代码同步，保证代码都是最新的。有历史记录控制。

版本控制：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版本控制工具，那么对配置文件的修改频率过高，因此很可能存在覆盖现象。有什么方式解决。

以上是关于JSP的主要内容，如果未能解决你的问题，请参考以下文章

JSPJSP指令

小峰servlet/jspjsp自定义标签

JSPJSP中的Java脚本

jspJSP 读取表单数据（含可运行源码.jsp&&.html）

JSP学习笔记-JSP原理，基本语法和指令

java基础 第十四章（Servlet声明周期Servlet向jsp中提供数据Servlet跳转jspjsp中书写java代码）