作用：通过网络浏览器可以远程访问web项目
tomcat：web服务器的一种，apache-tomcat-8.5.41-windows-x64.zip，解压，不用安装
安装路径：F:\tomcat8.5\apache-tomcat-8.5.41
bin：定义了启动管理服务器的程序 。
startup.bat:window操作系统启动服务器：需要环境变量配置jdk
startup.sh:linux操作系统启动服务器
shutdown.bat:window操作系统关闭服务器
shutdown.sh：linux操作系统关闭服务器
conf：tomcat服务器配置文件目录
server.xml：定义了tomcat服务器的端口号：8080，通过浏览器可以访问8080端口，就访问了该服务器
web.xml:定义session失效存活时间
lib:服务器提供的各种功能通过代码封装成jar包，我们的项目需要引入该jar包
webapps：默认项目发布目录，通过浏览器访问http://IP地址:8080/项目名，通过客户端浏览器访问服务器下的webapps/项目
work：tomcat将访问过的jsp封装成servlet源码
http://172.16.4.72:8090/test/1.html
window->preferences->Server->单击Runntime Environments->单击add->apache->apache tomcat8.5->next->Name:服务器名字随便填，单击Browser浏览选择tomcat安装根目录，选择自己安装的jre->完成
右键->new->project->Web->Dynamic web project:动态web项目->next->
Project name：填写项目名称，
Target Runtime:选择上面一步安装的tomcat->next->next->选中打勾：添加web.xml->完成
test1
java Resources
src 原来java项目中的src，写java源文件
libraries 自己的jdk和tomcat的jar包
webContent 静态网页资源目录：html css js img
Meta-inf 不管
web-inf
lib 所有项目需要自己的jar包考入即可
web.xml 项目的核心配置文件：定义了欢迎页面的路径：welcome-file-list
自己写一个静态页面测试访问
1：window->show view->Servers:下面出现服务器选项卡，单击超链接英文字母：添加刚才配置的服务器，完成
2：双击新出现的服务器：单击overview选项卡：找到server locations区域，选择第二个单选框更改web项目默认发布目录，单击borwser浏览，选择tomcat/webapps目录，ctrl+s保存，关闭选项卡
服务器右键->add and remove->将左边本地web项目添加到服务器的webapps目录完成
服务器右键->start 启动服务器
http://172.16.4.72:8090/test1/1.html
与昨天操作一致，注意必须手动导入mysql.jar包：原因mybatis逆向工程，只再java项目中找mysql.jar
tomcat提供的三大组件之一：作用：提供可以通过浏览器访问执行的类方法：
原来咱们自己定义的类中的方法，只能通过main函数，创建对象调用方法
tomcat提供了一个类叫做HttpServlet，该类中的方法可以通过浏览器访问执行。
就是HttpServlet的执行原理
在src上新建com.woniu.controller包：新建TestController类：
public class TestController extends HttpServlet{}
查看HttpServlet源码：
public abstract class javax.servlet.http.HttpServlet extends javax.servlet.GenericServlet {
private String abc;
public void init() {
System.out.println("TestController初始化");
}
public void init(ServletConfig config) {
//根据servlet配置对象，从web.xml文件中根据参数名获得参数值
abc = config.getInitParameter("bbb");
System.out.println("TestController初始化22222"+abc);
}
public void service(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException {
System.out.println("service.......");
//获得客户端的请求方式 GET、POST
String method = request.getMethod();
if("GET".equals(method)) {
this.doGet(request, response);
}else {
this.doPost(request, response);
}
}
public void doGet(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
System.out.println("doGet......，可以调用业务层的方法实现数据的CURD");
}
public void doPost(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
System.out.println("doPost......，可以调用业务层的方法实现数据的CURD");
}
public void destroy(){
for(int i=0;i<=100000;i++) {
System.out.println("当前对象被tomcat删除了");
}
}
}
自己定义一个类继承HttpServlet后，该类就有了HttpServlet类的特点和作用：
必须熟记理解这5个方法的执行原理
1：需要将自己定义了servlet子类信息定义在web.xml中
<!-- 创建一个servlet对象 -->
<servlet>
<!-- 定义该servlet的对象名字 TestController ttt = new TestController();-->
<servlet-name>ttt</servlet-name>
<servlet-class>com.woniu.controller.TestController</servlet-class>
<!-- 定义该servlet对象初始化的参数 -->
<init-param>
<param-name>aaa</param-name> <!-- 参数名 -->
<param-value>xxx</param-value> <!-- 参数值 -->
</init-param>
<!-- 定义该servlet对象初始化的第二个参数 -->
<init-param>
<param-name>bbb</param-name> <!-- 参数名 -->
<param-value>yyy</param-value> <!-- 参数值 -->
</init-param>
<!-- 定义该servlet对象是在： 1：启动服务器创建该对象；-1：在第一次访问该serlvet时创建该对象，默认 -->
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 定义servlet的请求路径 -->
<servlet-mapping>
<!-- 给ttt对象定义请求路径 -->
<servlet-name>ttt</servlet-name>
<!-- 定义ttt对象的请求路径是 /xxx.yyy -->
<url-pattern>/xxx.yyy</url-pattern>
</servlet-mapping>
执行原理：
1：启动服务器，tomcat会读取tomcat/webapps包中每一个web项目的web.xml,根据反射创建定义好的servlet对象(单例)，执行构造器了，该类通常不定义构造器。该方法永远只执行一次
2：启动服务器，创建对象之后，tomcat会调用该对象的init方法，初始化该对象：从web.xml读取参数给类属性赋值的过程称之为初始化。该方法永远只执行一次
3：客户端浏览器每次请求访问servlet时，都执行1次service方法：根据客户端的请求方式(get\post)，分别判断执行了doGet或者doPost方法
4：doGet或者doPost方法的作用具体执行客户端的业务，doGet和doPost接收参数的编码格式不同，doPost方法接收中文默认为ISO-8859-1不支持中文，doGet方法默认为UTF-8支持中文
5：关闭服务器执行destroy方法，tomcat销毁当前servlet对象
问题：当客户端发起请求后，执行了StuController中的doGet或者doPost方法，调用了业务层的一个方法，实现了添加功能，那么对于当前StuController类来说，没有方法再次调用业务层的其他方法了。
解决：修改StuController类的逻辑：
1：1个servlet可以定义多个请求路径
<servlet-mapping>
<!-- 给ttt对象定义请求路径 -->
<servlet-name>ttt</servlet-name>
<!-- 定义ttt对象的请求路径是 /xxx.yyy -->
<url-pattern>/x1.yyy</url-pattern>
<url-pattern>/x2.yyy</url-pattern>
<url-pattern>/x3.yyy</url-pattern>
</servlet-mapping>
2：每次请求都进入doGet或者doPost方法,修改doPost方法，调用doGet方法，意味着所有的请求都进入doGet方法，获得客户端的请求路径，根据不同的请求路径，反射执行了不同的自定义方法，不同的自定义方法可以调用不同的业务层方法。
public void doPost(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
//所有的请求方式都进入doGet
this.doGet(request, response);
}
public void doGet(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
try {
String uri = request.getRequestURI();
String methodName = uri.substring(7,uri.lastIndexOf("."));
Method metod = TestController.class.getDeclaredMethod(methodName, HttpServletRequest.class,HttpServletResponse.class);
metod.invoke(this,request,response);
} catch (Exception e) {
e.printStackTrace();
System.out.println("反射方法发生异常");
}
}
public void x1(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
System.out.println("调用了业务层实现添加功能");
}
public void x2(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
System.out.println("调用了业务层实现修改功能");
}
public void x3(HttpServletRequest request,HttpServletResponse response)
throws IOException,ServletException{
System.out.println("调用了业务层实现删除功能");
}
HttpServletRequest：请求对象：封装了客户端的所有参数,理解为一个容器
String type = request.getMethod();
System.out.println("客户端请求方式是="+type);
String path = request.getRealPath("/");
System.out.println("客户端请求项目的绝对路径="+path);
String uri = request.getRequestURI();
System.out.println("客户端请求servlet的路径="+uri); /项目名/x1.yyy
StringBuffer buffer = request.getRequestURL();
System.out.println("客户端请求servlet的网络路径="+buffer);
String add = request.getRemoteAddr();
System.out.println("客户端的ip=，但是这是局域网"+add);
//接收客户端的请求参数，根据参数名获得参数值
String value = request.getParameter("aaa");
System.out.println(value);
//获得转发对象
RequestDispatcher rdc = request.getRequestDispatcher("login.jsp");
//转发跳转
rdc.forward(request, response);
//将obj对象起个名字叫做name存在request对象中：该obj对象只能传递一次请求
request.setAttribute(String name,Object obj)
Object obj = request.getAttribute(String name)
HttpSession session = request.getSession();//获得session对象
//获得多选框参数，返回字符串数组
String[] box = request.getParameterValues("c1");
//获得客户端cookie缓存数据
Cookie[] cs = request.getCookies();
HttpServletResponse：响应对象：给客户端发送数据的对象
//获得字符输出流对象，给客户端发送数据
PrintWriter xxx = response.getWriter();
xxx.write("<font color='red'>xxxxx</font>");
//重定向跳转
response.sendRedirect("login.jsp");
//服务器给客户端浏览器发送一个Cookie数据
response.addCookie(Cookie c1);
HttpSession:会话对象，从第一次请求服务器开始到你离开服务器(关闭浏览器)称之为一次会话
//将obj对象起个名字叫做name存在session对象中：该obj对象只要再一次会话范围内，一直能用
session.setAttribute(String name,Object obj)
Object obj = session.getAttribute(String name)；
session.removeAttribute(String name)； //根据名字删除session对象中保存的对象
Cookie：在客户端浏览器上临时存储数据
ServletContext:servlet上下文对象，应用服务器对象
HttpSession session = se.getSession();
//通过session获得应用服务器对象(ServletContext:servlet上下文对象)
ServletContext context = session.getServletContext();
//将count1起个名字叫做counta存在服务器上，所有用户共享，作用域是application
context.setAttribute("counta", count1);
tomcat提供的三大组件之一：作用：提供在客户端请求servlet之前针对请求和响应对象进行过滤。
Filter：过滤器。
public class MyFilter1 implements Filter{
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
参数1/2；请求和响应对象
参数3：责任链对象：当客户端请求一次servlet时，服务器会创建一个责任链对象:
selCookie.do->login.jsp
login.do->userinfo.jsp
out.do->selCookie.do->login.jsp
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
}
web.xml:
<!-- 定义一个过滤器 -->
<filter>
<!-- 过滤器的名字 -->
<filter-name>f1</filter-name>
<!-- 过滤器的类路径 -->
<filter-class>com.woniu.filter.MyFilter1</filter-class>
<!-- 过滤器初始化参数 -->
<init-param>
<param-name>aaa</param-name>
<param-value>bbb</param-value>
</init-param>
</filter>
<!-- 过滤器的过滤路径 -->
<filter-mapping>
<!-- 过滤器的名字 -->
<filter-name>f1</filter-name>
<!-- 过滤器过滤的路径是什么：所有的servlet -->
<url-pattern>*.do</url-pattern>
</filter-mapping>
启动服务器，tomcat读取web.xml,创建过滤器对象，
执行init方法，该方法只执行一次：从核心配置文件中读取初始化参数，给类属性赋值。
客户端每次请求servlet时，都会先进入过滤器对象的doFilter方法：针对请求和响应对象进行过滤，默认会
拦截请求，针对请求和响应对象进行过滤完成后，要么放行，要么转发重定向跳转。
关闭服务器执行destroy方法销毁当前对象
tomcat三大组件之一：监听器：接口
HttpSessionListener:针对HttpSession对象的创建和销毁这两个动作进行监听。HttpSession对象的创建和销毁分别执行sessionCreated和sessionDestroyed的方法。
HttpSessionAttributeListener:针对HttpSession对象的添加、移除、替换更新属性时执行对应的方法
public class MyListener implements HttpSessionListener,HttpSessionAttributeListener{
private Integer count1 = 0;
private Integer count2 = 0;
@Override
public void sessionCreated(HttpSessionEvent se) {
System.out.println("session创建了");
count1++;
HttpSession session = se.getSession();
//通过session获得应用服务器对象(ServletContext:servlet上下文对象)
ServletContext context = session.getServletContext();
//将count1起个名字叫做counta存在服务器上，所有用户共享，作用域是application
context.setAttribute("counta", count1);
}
@Override
public void sessionDestroyed(HttpSessionEvent se) {
System.out.println("session销毁了");
count1--;
HttpSession session = se.getSession();
//通过session获得应用服务器对象(ServletContext:servlet上下文对象)
ServletContext context = session.getServletContext();
//将count1起个名字叫做counta存在服务器上，所有用户共享，作用域是application
context.setAttribute("counta", count1);
}
@Override
public void attributeAdded(HttpSessionBindingEvent event) {
// System.out.println("session添加对象了");
count2++;
HttpSession session = event.getSession();
//通过session获得应用服务器对象(ServletContext:servlet上下文对象)
ServletContext context = session.getServletContext();
//将count1起个名字叫做counta存在服务器上，所有用户共享，作用域是application
context.setAttribute("countb", count2);
}
@Override
public void attributeRemoved(HttpSessionBindingEvent event) {
//System.out.println("session移除对象了");
count2--;
HttpSession session = event.getSession();
//通过session获得应用服务器对象(ServletContext:servlet上下文对象)
ServletContext context = session.getServletContext();
//将count1起个名字叫做counta存在服务器上，所有用户共享，作用域是application
context.setAttribute("countb", count2);
}
@Override
public void attributeReplaced(HttpSessionBindingEvent event) {
//System.out.println("session替换更新对象了");
}
}
<listener>
<listener-class>com.woniu.listener.MyListener</listener-class>
</listener>
启动服务器创建该监听器对象，整个项目中HttpSession对象的创建和销毁分别执行sessionCreated和sessionDestroyed的方法。
生命周期：
当客户端访问服务器时，第一次获得session对象时，tomcat创建session对象，tomcat每创建一个session对象，都会有一个session的编号，叫做jsessionid(32位字符串)，将jsessionid直接发送给客户端保存在cookie中，客户端每次发起请求时，服务器通过对比该jsessionid来区分哪一个session对象对应哪一个客户端。
因为cookie数据默认存活时间为一次会话，所以当客户端关闭浏览器时，浏览器自动删除cookie中的jsessionid，而服务器不会销毁该session对象，当浏览器重新访问服务器时，会重新创建session对象，老session对象依然存活。session对象的销毁：
1：session.invalidate(); 销毁session对象
2：session.setMaxInactiveInterval(10); 当客户端与服务器失去联系超过10秒,销毁session对象
3：自己项目核心配置文件中:web.xml
<session-config> 当客户端与服务器失去联系超过10分钟,销毁session对象
<session-timeout>10</session-timeout>
</session-config>
4：tomcat配置文件：conf/web.xml: 默认30分钟
<session-config>
<session-timeout>30</session-timeout>
</session-config>
作用：在客户端浏览器上临时存储数据，默认该数据存储就是一次会话，关闭浏览器自动删除该数据，存储数据键值对必须都是String，
服务器通过响应对象给客户端浏览器发送该cookie数据保存，浏览器F12->network->doc->刷新页面->单击当前请求地址
Cookie c2 = new Cookie("x2",upwd);
c2.setMaxAge(60*60*24*7);
response.addCookie(c2);
//获得客户端cookie缓存数据
Cookie[] cs = request.getCookies();
if(cs != null) {
for(int i=0;i<cs.length;i++) {
Cookie c1 = cs[i];
System.out.println(c1.getName()+"===="+c1.getValue());
}
}
M：model 模型层代码(service+entity)->调用底层持久层:dao包
V：view 视图层代码：html、jsp
C：controller 控制层代码：就是controller包中的类，接收参数、调用业务层方法，传递参数，跳转
jsp->调用controller->service->dao
//获得转发对象
RequestDispatcher rdc = request.getRequestDispatcher("login.jsp");
//转发跳转
rdc.forward(request, response);
//重定向跳转
response.sendRedirect("login.jsp");
区别：转发跳转地址不变，属于一次请求，servlet可以通过request对象给下个页面传递参数
重定向跳转地址变化，服务器控制客户端浏览器的地址栏改变，属于二次请求，servlet不可以通过request对象给下个页面传递参数
通常：servlet不用给下个页面传参，则重定向跳转，需要传参则转发跳转
java server pages:java 服务器 页面技术
jsp：就是将静态页面html+java代码组成了jsp，
注意：
1:jsp上所有的路径全部从： /项目名开始找目标路径
2:servlet中的找页面的路径默认全部从webContent包开始找
编译指令：
<%@ page %>:定义当前页面如何编译，
标签指令：给当前页面引入一个合法标签
<%@ taglib%>
包含指令：当前页面的该位置包含另外一个页面
<%@ include file="包含页面的相对路径" %>
当客户第一次放jsp时，tomcat将jsp页面封装了servlet，执行service方法，通过response获得输出流对象，将html、css、js通过流对象发送给客户端浏览器：请看服务器各个文件夹的作用
作用：从四大作用域中获取对象
四大作用域：
当前页面(page) ${pageScope.name}
一次请求(request) ${requestScope.name}
一会会话(session) ${sessionScope.name}
应用服务器(application) ${applicationScope.name}
${pageScope.name}:从当前页面对象中根据名字获得对象：
${requestScope.name}:从request对象中根据名字获得对象：
Object obj = request.getAttribute(String name)
${sessionScope.name}:从session对象中根据名字获得对象：
Object obj = session.getAttribute(String name)
${applicationScope.name}
Object obj = servletContext.getAttribute(String name)
${requestScope.U.ubeiyong1 eq "男"?"checked=checked":""}
eq:相等判断
gt:大于判断
lt:小于判断
核心标签标签库：作用：在页面上能够进行判断、循环、数据格式化
1：引入standard.jar和jstl.jar
2：在页面最上面添加：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> c标签可以循环、判断
<c:if test="${sessionScope.U.urole eq 3 }"></c:if>
<c:forEach items="要循环的对象" var="迭代出来每一个对象的名字"></c:forEach>
<c:forEach items="${requestScope.info.list }" var="xxx"></c:forEach>
for(int i=0;i<requestScope.info.list.size();i++){
Object xxx = requestScope.info.list.get(i);
}
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> fmt标签可以格式化数据
将Date转成String
<fmt:formatDate value="${sessionScope.U.utime }" pattern="yyyy-MM-dd HH:mm:ss"/>
<form></form>
<a href="/test1/xxx.do?a=1&b=2&c=3"></a>
<button onclick="aaa()"></button> functioin aaa(){location.href="xxx.do?a=1&b+2&c=3"}
sessionStorage：在客户端浏览器上临时存储一个键值对数据，都是字符串类型，当关闭浏览器时，清除该数据
sessionStorage.setItem("aaa","111");
var aa = sessionStorage.getItem("aaa");
localStorage：在客户端浏览器上临时存储一个键值对数据，都是字符串类型，永久存储，可以手动删除
localStorage.setItem("aaa","111");
var aa = localStorage.getItem("aaa");
F12->application
元注解、第三方注解、自定义注解
jdk提供的注解：
@Override：提示信息，方法重写
@Target(ElementType.METHOD) //定义自己定义注解(MyAnnotation)的类型：方法注解
@Retention(RetentionPolicy.RUNTIME) //定义自己定义注解(MyAnnotation)的类型：运行时注解
通过自己引入的第三方jar包中提供的注解
tomcat：提供了三组组件的注解，代替了web.xml的描述
@WebServlet(
loadOnStartup = 1,
urlPatterns = {"/selCookie.do","/out.do","/updateUserinfo.do","/login.do","/regist.do"}
)
public class UserinfoController extends SuperServlet{}
@WebFilter(
urlPatterns = {"*.do"},
initParams = @WebInitParam(name = "aaa",value = "UTF-8")
)
public class MyFilter1 implements Filter{}
@WebListener
public class MyListener implements HttpSessionListener,HttpSessionAttributeListener{}
语法结构定义：
@Target(ElementType.METHOD) //定义自己定义注解(MyAnnotation)的类型：方法注解
@Retention(RetentionPolicy.RUNTIME) //定义自己定义注解(MyAnnotation)的类型：运行时注解：可以在方法运行时，只能在反射执行方法时获得自定义注解的属性值
public @interface MyAnnotation {
String aaa(); //自定义注解的属性，只能是基本数据类型和字符串
int bbb();
}
自定义注解的使用：任意方法头上面使用，使用注解时给属性赋值，注意：当自定义属性有且只有一个属性叫做value时，使用赋值时可以不写属性名
@MyAnnotation(aaa ="安全退出",bbb=10)
public void out(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException{
}
@MyAnnotation("修改状态")
public void updateGflag1(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException{
}
获得自定义注解的属性值：
Method method = this.getClass().getDeclaredMethod(methodName,
HttpServletRequest.class,HttpServletResponse.class);
//根据method对象获得该方法对象的注解对象
MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
//获得该注解对象的属性值
String str1 = myAnnotation.value();
System.out.println(str1);
1：上传域添加选项改变事件：
<input type="file" name="usrc" @change="upload($event.target)" multiple="multiple">
2：自定义方法：
1:判断上传文件个数、后缀
2：上传文件存储在FormDate对象中：{ff:[file1,file2,file3]}
3：异步上传：注意：headers(请求头格式)、method(请求方式)、data(请求参数)
upload(obj){
//console.log(obj);
//上传域对象,obj.files:获得上传对象中上传的文件数组
//var obj = document.getElementById("xxx");
if(obj.files.length == 3){
for(var i=0;i<obj.files.length;i++){
var end = [".jpg",".jpeg",".png"];
var dian = obj.files[i].name.lastIndexOf(".");
var sub = obj.files[i].name.substring(dian);
if(end.indexOf(sub) == -1){
alert("只能上传.jpg,.jpeg,.png的文件");
return;
}
}
//json对象，以键值对存储对象,当键名相同是，所有的value值存储成数组
var formData = new FormData();
for(var i=0;i<obj.files.length;i++){
formData.append("ff",obj.files[i]);
}
//{ff:[file1,file2,file3]}
axios({
baseURL:"http://localhost:8090/test1",
url:"/upload.do",
method:"post", //上传必须是post方式
headers:{"Content-Type":"multipart/form-data"},//字节流提交参数
//params:{aaa:"a1111",bbb:"a222"},
data:formData,
responseType:"text"
}).then(response=>{
});
}else{
alert("只能上传一个图片");
}
}
注意：前端异步请求时，发起的请求参数以字节流方式传参，那么默认request.getParamter接收不到参数
所以：引入第三方jar包接收文件：commons-fileupload-1.4.jar和commons-io-2.11.0.jar
//文件选项工厂对象
DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();
//创建servlet文件上传工具类
ServletFileUpload servletFileUpload = new ServletFileUpload(diskFileItemFactory);
//通过工具类解析请求对象，将请求对象中所有的上传文件，解析成集合,FileItem:表单元素
List<FileItem> list = servletFileUpload.parseRequest(request);
for (FileItem fileItem : list) {
//System.out.println(fileItem);
String path1 = request.getRealPath("/");
String path2 = "upload/"+new Date().getTime()+new Random().nextInt(10000)+fileItem.getName().substring(fileItem.getName().lastIndexOf("."));
File f1 = new File(path1+path2);
fileItem.write(f1); //将fileItem另存为f1
response.getWriter().write(path2);
}
原理：将远程服务器上的文件通过IO流可以复制到客户端
servlet中需要设置响应头：响应头的作用就是控制该servlet执行完成后返回字符串或者下载文件：控制响应的方式
//控制响应头为下载模式：下载文件名是filename
response.setHeader("Content-Disposition", "attachment;filename=xxx.xls");
String name = "1.xls";
File f1 = new File(request.getRealPath("/")+"upload3/"+name);
FileInputStream fis = new FileInputStream(f1);
//获得servlet字节输出流：给客户端流文件
ServletOutputStream outputStream = response.getOutputStream();
byte[] b = new byte[1024];
int n;
while( (n = fis.read(b, 0,b.length))!= -1) {
outputStream.write(b);
}
fis.close();
outputStream.close();
沙箱环境（Sandbox）：支付宝虚拟系统程序，支付宝沙箱环境就是真实支付宝环境的模拟。开发时在沙箱环境中开发，对沙箱环境的操作不会产生实际效果，测试支付无误后，可以移植到真实环境中，移植到真实环境中只需要把电子凭证替换成真实凭证，支付逻辑不变。
1：下载沙箱案例：https://opendocs.alipay.com/open/270/106291
2：解压案例：eclipse导入该项目，替换该项目tomcat版本。
3：项目编译到tomcat，启动服务器测试该项目。
4：访问：http://localhost:8080/alipay.trade.page.pay-JAVA-UTF-8/，项目首页index.jsp，点击付款，出现500异常，稍后修改（更改：AlipayConfig.java(沙箱支付配置类)）
5：进入支付宝开放平台：https://open.alipay.com/，扫码，注册，使用。
6：进入控制台->沙箱:模拟一套买家和卖家信息(授权)
7：给AlipayConfig.java的类属性赋值：
将APPID考入AlipayConfig.java的app_id属性，
将支付宝网关地址考入gatewayUrl属性，
系统默认密钥：公钥模式：查看
将应用私钥拷贝到商户私钥merchant_private_key属性中(查看公钥中)
将支付宝公钥拷贝到支付宝公钥alipay_public_key属性中(查看公钥中)
8：重启服务器，点击支付，填写沙箱买家账号与密码(提示谨防钓鱼网站，清空浏览器缓存)，下一步，填写支付密码，确认付款。
支付成功后，自动跳回应用页面无法访问：需要配置。
9：AlipayConfig.java中定义notify_url与return_url的成功付款路径：
notify_url = "http://localhost:8080/自己项目名/test.jsp" 同步请求
return_url = "http://localhost:8080/自己项目名/test.jsp" 异步请求
将沙箱项目移植到自己的项目中：
AlipayConfig.java
所有jsp
jar包
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
