JSP&EL&JSTL

旧城等待， 2021-11-17 00:30 308阅读 0赞

介绍：

什么是jsp java servlet page

jsp就是一个Java类 ，他继承了Servlet ,所以jsp就是一个Servlet

为什么会有jsp

html 是静态的，但使用中我们需要在页面显示动态的数据，这时候JSP 就可以满足这个要求Jsp 可以编写Java代码。

使用jsp

三大指令： 指令的语法<%@ 指令名字%>

1.  page ：  
    language:  
    表明jsp 页面可以写Java 代码  
    contentType：  
    其实即使说这个文件是什么类型，告诉浏览器我是什么内容类型，以及使用什么编码  
    contentType=“text/html;charset=uft-8”  
    text/html MIMEType 这是一个文本，html网页  
    pageEncoding：  
    jsp内容编码  
    extends:  
    指定jsp 翻译成Java 文件后，继承的父类是谁，一般不用改。  
    import:  
    导包使用的，一般不用手写。  
    session:  
    值可选的有true or false .  
    用于控制在这个jsp页面里面，能够直接使用session对象。  
    具体的区别是，请看翻译后的java文件 如果该值是true , 那么在代码里面会有getSession（）的调用，如果是false : 那么就不会有该方法调用，也就是没有session对象了。在页面上自然也就不能使用session了。  
    errorPage:  
    指的是错误的页面，值需要给错误的页面路径  
    isErrorPage:  
    表示是个错误页面，上面的errorPage 用于指定错误的时候跑到哪一个页面去。 那么这个isErroPage , 就是声明某一个页面到底是不是错误的页面。
2.  taglib:  
    <%@ taglib prefix="" uri=""%>  
    uri: 标签库路径  
    prefix : 标签库的别名
3.  include  
    包含另外一个jsp的内容进来。  
    <%@ include file=“other02.jsp”%>  
    注意：  
    这个包含是静态的，把另外一个页面的所有内容拿过来一起输出。 所有的标签元素都包含进来
    
    #### JSP 动作标签 ####
    
    <jsp:include page=""></jsp:include>  
    <jsp:forward page=""></jsp:forward>  
    <jsp:param value="" name=""/>

1jsp:include

<jsp:include page="">/jsp:include

包含指定的页面， 这里是动态包含。 也就是不把包含的页面所有元素标签全部拿过来输出，而是把它的运行结果拿过来。

2jsp:forward

<jsp:forward page="">/jsp:forward

前往哪一个页面。 (类似请求转发)

3jsp:param

意思是： 在包含某个页面的时候，或者在跳转某个页面的时候，加入这个参数。

<jsp:forward page="other02.jsp">
    	<jsp:param value="beijing" name="address"/>
    </jsp:forward>

在other02.jsp 页面可以得到参数：

<%=request.getparameter(“address”)%>

#### JSP内置对象 ####

内置对象就是可以直接在jsp中使用这些对象，不用创建

*  pageContext
 *  request
 *  session
 *  application

以上4个作用域对象

作用域 ：

表示这些对象可以存值，他们的取值范围有限定。 setAttribute 和 getAttribute

使用作用域来存储数据

作用域范围大小：

pageContext – request — session – application

#### 四个作用域的区别 ####

*  pageContext 【PageContext】

作用域仅限于当前的页面。

还可以获取到其他八个内置对象。

*  request 【HttpServletRequest】

作用域仅限于一次请求， 只要服务器对该请求做出了响应。 这个域中存的值就没有了。

*  session 【HttpSession】

作用域限于一次会话（多次请求与响应） 当中。

*  application 【ServletContext】

整个工程都可以访问， 服务器关闭后就不能访问了。

*  out 【JspWriter】
    
     *  response 【HttpServletResponse】
 *  exception 【Throwable】----要加error page 中加入
    
     *  page 【Object】 —就是这个jsp翻译成的java类的实例对象
        
         *  config 【ServletConfig】------------获得初始化的一些配置对象

#### El表达式 ####

是为了简化咱们的jsp代码，具体一点就是为了简化在jsp里面写的那些java代码。

*  写法格式

$\{表达式 \}

如果从作用域中取值，会先从小的作用域开始取，如果没有，就往下一个作用域取。 一直把四个作用域取完都没有， 就没有显示。

<%
    		pageContext.setAttribute("name", "page");
    		request.setAttribute("name", "request");
    		session.setAttribute("name", "session");
    		application.setAttribute("name", "application");
    	%>
    	
    	按普通手段取值<br>
    	
    	<%= pageContext.getAttribute("name")%>
    	<%= request.getAttribute("name")%>
    	<%= session.getAttribute("name")%>
    	<%= application.getAttribute("name")%>
    	
    	<br>使用EL表达式取出作用域中的值<br>
    	
    	${ pageScope.name }
    	${ requestScope.name }
    	${ sessionScope.name }
    	${ applicationScope.name }

2,EL表达式获取数组的数据

<h1>El表达式取数组的数据</h1>
    	<%
    		String[] name = { "aa", "bb", "cc", "dd" };
    		pageContext.setAttribute("name", name);
    	%>
    	${name[0]} ,${name[1]},${name[2]}

3，EL表达下获取集合的数据

<h1>El表达式取集合的</h1>
    	<%
    		ArrayList list = new ArrayList();//他的底层是数组,所以是和拿数组的方法一样
    		list.add(1);
    		list.add(2);
    		list.add(3);
    		list.add(4);
    		pageContext.setAttribute("list", list);
    	%>
        
    	${list[1]}

4，EL表达下获取Map的数据

<h1>EL表达式拿Map的值</h1>
    	<%
    		HashMap map = new HashMap();
    		map.put("weng", 11);
    		map.put("22", 22);
    		map.put("33", 33);
    		map.put("44", 44);
    		map.put("abma.in", "特殊");
    		session.setAttribute("map", map);
    	%>
    	
    	${map.weng}
    	
    		${map["abma.in"]}

#### 取值细节： ####

1.  从域中取值。 得先存值。  
    <%  
    //pageContext.setAttribute(“name”, “zhangsan”);  
    session.setAttribute(“name”, “lisi…”);  
    %>  
      
    直接指定说了，到这个作用域里面去找这个name  
      
    $\{ [pageScope.name][] \}
    
      
    //先从page里面找，没有去request找，去session，去application  
      
    $\{ name \}
    
      
    指定从session中取值  
      
    $\{ [sessionScope.name][] \}
2.  取值方式

如果这份值是有下标的，那么直接使用\[\]

<%
    	String [] array = {"aa","bb","cc"}
    	session.setAttribute("array",array);
    %>
    
    ${ array[1] } --> 这里array说的是attribute的name

如果没有下标， 直接使用 .的方式去取

<%
    	User user = new User("zhangsan",18);
    	
    	session.setAttribute("u", user);
    %>
    
    ${ u.name }  , ${ u.age }

一般使用EL表达式，用的比较多的，都是从一个对象中取出它的属性值，比如取出某一个学生的姓名。

EL表达式 的11个内置对象。

$\{ 对象名.成员 \}

*  pageContext

作用域相关对象

*  pageScope
 *  requestScope
 *  sessionScope
 *  applicationScope

头信息相关对象

*  header
 *  headerValues

参数信息相关对象

*  param
 *  paramValues
 *  cookie  
    全局初始化参数
 *  initParam

JSTL

全称 ： JSP Standard Tag Library jsp标准标签库

简化jsp的代码编写。 替换 <%%> 写法。 一般与EL表达式配合

怎么使用

1.  导入jar文件到工程的WebContent/Web-Inf/lib jstl.jar standard.jar
2.  在jsp页面上，使用taglib 指令，来引入标签库
3.  注意： 如果想支持 EL表达式，那么引入的标签库必须选择1.1的版本，1.0的版本不支持EL表达式。
    
    <%@ taglib prefix=“c” uri=“[http://java.sun.com/jsp/jstl/core][http_java.sun.com_jsp_jstl_core]” %>

常用的标签

<c:set></c:set>
    <c:if test=""></c:if>
    <c:foreach></c:foreach>

c:set:

<c:set var="name" value="wengyanmin" scope="session"></c:set>
    	${sessionScope.name }

c:if :

<c:if test="${age>=18}">
    		年龄大于18
    	</c:if>
    	
    	<c:if test="${age>=18}" var="result" scope="session">
    		年龄大于18
    	</c:if>
    	
    	${result}

c:foreach:

<c:forEach begin="1" end="10" var="i" step="2">
    	${i}
    	</c:forEach>
    	
    	<h1>常用foreach的使用方法：</h1>
    	<%
    		ArrayList list=new ArrayList();
    		list.add(new User("weng",1));
    		list.add(new User("yan",2));
    		list.add(new User("min",3));
    		pageContext.setAttribute("list", list);	
    	%>
    	
    	<c:forEach var="user" items="${list}">
    		${user.name }=======${user.age }
    	</c:forEach>

#### 例子 :学生信息管理系统 ####

1.  先写 login.jsp , 并且搭配一个LoginServlet 去获取登录信息。
2.  创建用户表， 里面只要有id , username 和 password
3.  创建UserDao, 定义登录的方法  
    /\*\*
    
     *  该dao定义了对用户表的访问规则  
        */  
        public interface UserDao \{  
        /*\*
        
         *  ## 这里简单就返回一个Boolean类型， 成功或者失败即可。 ##
            
             *  但是开发的时候，登录的方法，一旦成功。这里应该返回该用户的个人信息
             *  @param userName
             *  @param password
             *  
             *  @return true : 登录成功， false : 登录失败。  
                \*/  
                boolean login(String userName , String password);  
                \}
4.  创建UserDaoImpl , 实现刚才定义的登录方法。
    
        public class UserDaoImpl implements UserDao {
        
         	@Override
         	public boolean login(String userName , String password) {
         		
         		Connection conn = null;
         		PreparedStatement ps = null;
         		ResultSet rs   = null;
         		try {
         			//1. 得到连接对象
         			conn = JDBCUtil.getConn();
         			
         			String sql = "select * from t_user where username=? and password=?";
         			
         			//2. 创建ps对象
         			ps = conn.prepareStatement(sql);
         			ps.setString(1, userName);
         			ps.setString(2, password);
        
         			//3. 开始执行。
         			rs = ps.executeQuery();
         			
         			//如果能够成功移到下一条记录，那么表明有这个用户。 
         			return rs.next();
         			
         		} catch (SQLException e) {
         			e.printStackTrace();
         		}finally {
         			JDBCUtil.release(conn, ps, rs);
         		}
         		return false;
         	}
         
         }
5.  在LoginServlet里面访问UserDao， 判断登录结果。 以区分对待
6.  创建stu\_list.jsp , 让登录成功的时候跳转过去。
7.  创建学生表 ， 里面字段随意。
8.  定义学生的Dao . StuDao
    
        public interface StuDao {
        
         	/**
         	 * 查询出来所有的学生信息
         	 * @return List集合
         	 */
         	List<Student> findAll();
         }
9.  对上面定义的StuDao 做出实现 StuDaoImpl  
    public class StuDaoImpl implements StuDao \{  
    @Override  
    public List findAll() \{  
    List list = new ArrayList();  
    Connection conn = null;  
    PreparedStatement ps = null;  
    ResultSet rs = null;  
    try \{  
    //1. 得到连接对象  
    conn = JDBCUtil.getConn();
    
        String sql = "select * from t_stu";
         		
         		ps = conn.prepareStatement(sql);
         		
         		rs = ps.executeQuery();
        
         		
         		//数据多了，用对象装， 对象也多了呢？ 用集合装。 
         		while(rs.next()){ //10 次 ，10个学生
         			
         			Student stu = new Student();
         			
         			stu.setId(rs.getInt("id"));
         			stu.setAge(rs.getInt("age"));
         			stu.setName(rs.getString("name"));
         			stu.setGender(rs.getString("gender"));
         			stu.setAddress(rs.getString("address"));
         			
         			list.add(stu);
         			
         		}
         	} catch (SQLException e) {
         		e.printStackTrace();
         	}finally {
         		JDBCUtil.release(conn, ps, rs);
         	}
         	
         	return list;
         }
    
    \}
10. 在登录成功的时候，完成三件事情。
11. 查询所有的学生  
    2. 把这个所有的学生集合存储到作用域中。  
    3. 跳转到stu\_list.jsp
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        	//提交的数据有可能有中文， 怎么处理。
        	request.setCharacterEncoding("UTF-8");
        	response.setContentType("text/html;charset=utf-8");
        	
        	//1. 获取客户端提交的信息
        	String userName = request.getParameter("username");
        	String password = request.getParameter("password");
        	
        	//2. 去访问dao ， 看看是否满足登录。
        	UserDao dao = new UserDaoImpl();
        	boolean isSuccess = dao.login(userName, password);
        	
        	//3. 针对dao的返回结果，做出响应
        	if(isSuccess){
        		//response.getWriter().write("登录成功.");
        		
        		//1. 查询出来所有的学生信息。
        		StuDao stuDao = new StuDaoImpl();
        		List<Student> list = stuDao.findAll();
        		
        		//2. 先把这个集合存到作用域中。
        		request.getSession().setAttribute("list", list);
        		
        		//2. 重定向
        		response.sendRedirect("stu_list.jsp");
        		
        	}else{
        		response.getWriter().write("用户名或者密码错误！");
        	}
        }
12. 在stu\_list.jsp中，取出域中的集合，然后使用c标签 去遍历集合。
    
        <table border="1" width="700">
        <tr align="center">
        	<td>编号</td>
        	<td>姓名</td>
        	<td>年龄</td>
        	<td>性别</td>
        	<td>住址</td>
        	<td>操作</td>
        </tr>
        
        <c:forEach items="${list }" var="stu">
        	<tr align="center">
        		<td>${stu.id }</td>
        		<td>${stu.name }</td>
        		<td>${stu.age }</td>
        		<td>${stu.gender }</td>
        		<td>${stu.address }</td>
        		<td><a href="#">更新</a>   <a href="#">删除</a></td>
        	</tr>
        </c:forEach>

总结：

*  JSP  
    三大指令  
    page  
    include  
    taglib
    
    三个动作标签  
    jsp:include  
    jsp:forward  
    jsp:param
    
    九个内置对象
    
        四个作用域
          	pageContext
          	request
          	session
          	application
        
          out
          exception
          response
          page
          config
 *  EL  
    $\{ 表达式 \}  
    取4个作用域中的值  
    $\{ name \}  
    有11个内置对象。  
    pageContext
    
        pageScope
        requestScope
        sessionScope
        applicationScope
        
        header
        headerValues
        
        param
        paramValues
        
        cookie
        initParam
 *  JSTL

使用1.1的版本， 支持EL表达式， 1.0不支持EL表达式

拷贝jar包， 通过taglib 去引入标签库

<c:set>
    <c:if>
    <c:forEach>

[pageScope.name]: http://pageScope.name
[sessionScope.name]: http://sessionScope.name
[http_java.sun.com_jsp_jstl_core]: http://java.sun.com/jsp/jstl/core

JSP&EL&JSTL

发表评论取消回复

还没有评论，来说两句吧...

相关阅读