前后端交互

Day1

CSS伪类选择器

描述一个标签元素经历过状态
没有访问过的状态link
鼠标悬停状态hover
鼠标激活状态active
访问过的状态visited
​
        在css代码块中
            选择器:状态{
                书写样式代码
            }
            
在 CSS 定义中，a:hover 必须被置于 a:link 和 a:visited 之后，才是有效的。    
在 CSS 定义中，a:active 必须被置于 a:hover 之后，才是有效的。
伪类名称对大小写不敏感。

代码书写

 <style>
        /*没有访问过的状态*/
        a:link{
            /*字体尺寸样式*/
            font-size: 20px;
            color: red;
            /*文本修饰*/
            text-decoration: none;
        }
​
        /*访问过的状态*/
        a:visited{
            font-size: 35px;
            color: darkgrey;
        }
​
        /*鼠标悬停状态*/
        a:hover{
            font-size: 30px;
            color: blue;
            text-decoration: underline;
​
        }
        /*激活状态:点击但是没有松开*/
        a:active{
            font-size: 25px;
            color: greenyellow;
            text-decoration: none;
        }
​
​
    </style>
​
<div>
<a href="跳转.html">点击跳转</a>
</div>

CSS文本选择器

文本颜色:color
 
行高:line-height
​
letter-spacing:字符间距
​
text-align:设置文本内容对齐方式
  
text-decoration 属性:设置文本的是否有下划线
                overline:上划线
                underLine:下划线
                line-through:中划线
 word-spacing：单词间距
 系统认为:两个字组成一个单词           

<style>
        body{
            /*文本颜色:color*/
            color: red;
            /*行高:line-height*/
            line-height: 50px;
            /*letter-spacing:字符间距*/
            letter-spacing: 10px;
            /*text-align:设置文本内容对齐方式*/
            text-align: center;
            /*text-decoration 属性:设置文本的是否有下划线
                overline:上划线
                underLine:下划线
                line-through:中划线
            */
            text-decoration: line-through;
​
​
            /*
                word-spacing：单词间距
                系统认为:两个字组成一个单词
            */
            word-spacing: 100px;
        }
​
    </style>

CSS背景

<style>
给body中设置相关的背景样式:
​
body{
background-color:设置背景颜色
background-color: darkgrey;
​
background-image:将图像设置背景
如果这个图像尺寸大小不是当前系统默认的分辨率尺寸
这个图像就会重复复制,X轴和Y轴在同时复制
background-image: url("img/mv.jpg");
background-repeat:设置图像是否重复以及如何重复
                默认值:repeat(x轴/y轴重复)
​
                repeat-x:x轴重复
                repeat-y:y轴重复
                no-repeat: (不重复)推荐
background-repeat: no-repeat;
​
background-position:设置图像的起始位置
                   图像的位置 在浏览器中的显示位置
                   默认值:就是top left
background-position: top center;
​
推荐:背景样式的简写属性
            background:
            background-color
            background-position
            background-repeat
            background-image
            
 background: darkgrey top left no-repeat  ; 
 
}
</style>

CSS边框样式

CSS边框样式:有4个边
​
先去设置四个边的颜色:
        border-top-color: red;
        border-left-color: greenyellow;
        border-bottom-color: blue;
        border-right-color: darkgreen;
        
 1)边框四个边的颜色,宽度,以及样式都有一个默认的方向:
                上右下左
​
2)某一边没有设置颜色,宽度以及样式:会使用对边的颜色和宽度以及样式
                颜色/宽度/样式的简写属性
​
再去设置四个边的宽度
        border-top-width: 10px;
        border-left-width: 20px;
        border-bottom-width: 30px;
        border-right-width: 40px;
        border-width: 1px ;
        
要显示边框出来,必须要指定的边框的样式属性
        border-style
        solid:单实线
        double:双实线
        dashed:虚线
        dotted:点
        
    border-top-style: solid;
    border-left-style: double;
    border-bottom-style: dashed;
    border-right-style: dotted;
    border-style: solid ;
    
border的简写属性:
    border-width
    border-style
    border-color
    
 <style>
        div{

代码实现

 <style>
        div{
            border:2px solid black; //边框黑色单实线   
            width: 100px;
            height: 100px; //设置边框大小
        }
    </style>

CSS浮动属性

浮动属性:float
        left:向左浮动,碰到外边框停止浮动
        right:向右浮动...
        
不浮动属性:
        clear
        :left:左不浮动
        right:右不浮动
        both:左右两边都不浮动                        

代码实现

 <style>
​
        .c1{
            border: 1px solid #000;
            background-color: red;
            width: 200px;
            height: 200px ;
​
            /*浮动属性:float
                left:向左浮动,碰到外边框停止浮动
                right:向右浮动...
               */
            float: left;
        }
        .c2{
            border: 1px solid #000;
            background-color: greenyellow;
            width: 200px;
            height:200px ;
            float: left;
        }
        .c3{
            border: 1px solid #000;
            background-color: blue;
            width: 200px;
            height: 200px ;
            float: left;
        }
​
        /*.clear{
​
         */
​
            /*不浮动属性
                一般推荐:both:两边都不浮动
            */
        /*
            clear: both;
        }
        */
    </style>

CSS盒子模型

万物皆盒子,可以将任意html标签看成一个盒子
将任意的元素使用div包裹起来,通过选择器(id/class)控制任意元素
​
盒子具备的属性:
容量大小:给div元素包裹的内容设置width和length
​
盒子的厚度:border,当前的边框大小
盒子的内边距:padding,控制盒子的内容,和border之间的距离
盒子的外边距:margin:控制的是盒子与盒子之间的距离(使用居多,可以控制盒子进行左/右外边距进行移动)
​
padding和margin也具备边框的基本特点
默认方向:上,右,下,左
如果一边未设置,补齐对边的距离
​

Servlet

servlet 全称"server applet" 
servlet是运行在 Web服务器中的小型Java程序。
servlet通常通过HTTP(超文本传输协议）接收和响应来自Web客户端的请求。
​
定义一个serlet:
    1) 自定义一个类,继承HttpServlet
        重写HttpServlet里面doGet(),doPost方法.
    2)配置servlet:在WEB-INF的web.xml文件中配置指定的servlet
        在web.xml中配置
        
Servlet就是能够实现Servlet接口的普通类!

配置web.xml

 //配置servlet基本配置
<servlet>
//配置servlet的名称
<servlet-name>名称</servlet-name>
//配置当前MyFirstServlet的全限定名称
<servlet-class>com.qf.web.MyFirstServlet</servlet-class>
</servlet>
​
​
//servlet的映射配置
<servlet-mapping>
<servlet-name>名称</servlet-name>//名称必须要配置与servlet名称的<servlet-name>保持一致
<url-pattern>/helloServlet</url-pattern>
</servlet-mapping>

servlet中文乱码解决

// response.getWriter().write("今天天气针不戳//打印时出现乱码
//解决响应的中文乱码
response.setContentType("text/html;charset=utf-8");//使用utf-8,避免乱码
PrintWriter writer = response.getWriter();//字符打印流
writer.write("输的什么液,想你的液!!");

servlet体系结构

MyFistServlt--继承-->HttpServlet--继承-->GenericServlet--implements实现接口-->Servlet
​
Servlet接口:定义一些相关Servlet生命周期相关的方法
init(ServletConfig config)
初始化
​
service(ServletRequest request,ServletResponse response)
是web服务器解析业务方法的入口(服务方法)
​
public void destroy () : servlet的销毁方法
​
​
GenericServlet:
获取具体的ServletConfig:配置对象:获取配置参数
获取具体的全局对象:ServletContext(域对象)
域对象:实现web容器之间数据通信
域对象:实现容器之间数据通信
​
HttpServlet:
重写service方法
针对用户不同的提交方式执行不同的doXXX(doGet()doPost())
​
自定义一个类:
重写具体的HttpServlet里面
doGet()/doPost()完成我们自己的get或者post提交方式的业务!.
​
Http协议的规范规定格式
HttpServletRequest 请求对象
HttpServletResponse 响应对象

Servlet执行流程

1)用户发送Http请求---将请求的信息内容封装到HttpServletRequest(请求对象中)
​
​
​
tomcat服务器启动完成
1)解析url
工程路径名称/配置Servlet的映射路径
2)在web.xml中寻找是否存在url-pattern的内容为:/配置Servlet的映射路径
​
3)获取对应的名称<servlet-name>MyFirstServlet</servlet-name)
​
4)通过名字找到servlet的名称中是否有MyFirstServlet
​
5)配置servlet基本设置
<servlet>
//配置servlet的名称
<servlet-name>MyFirstServlet</servlet-name>
//配置当前MyFirstServlet的全限定名称
<servlet-class>(工程名称(包名.类名))</servlet-class>
</servlet>
​
​
tomcat服务器需要解析xml文件
​
dom解析(基于面向对象):dom4j的方式dom for java
使用dom解析
获取到Servlet-class标签对象,通过标签对象获取文本内容:" 工程路径名称(包名.类名)"
得到:
Class<MyFirstServelt> clazz = Class.forName ( "com. qf.web.MyFristServlet" )
0bject obj =clazz.newInstance();
​
Method = clazz.getDeclaredMethod("doGet",HttpServletRequest.class,
HttpServletResponse.class)
​
调用
m.invoke (obj, request, response) :
​
sax解析(基于事件编程)

Servlet生命周期

默认情况下对象只创建一次
初始化也只初始化一次!
而service方法,被调用多次,里面覆盖的应该具体的doXXX()方式(根据不同的提交方式执行不同的doXXX)
​
当前serlvet类对象什么时候创建?默认的时候,
访问servlet的时候创建当前类的实例,而且是单例的,在内存中始终只有一个对象
也可以通过在servlet配置中:<load-on-startup>1</load-on-startup>配置初始化时机,当前tomcat启动的时候创建当前类对象
以及进行初始化操作!
​
​
​
配置servlet初始化时机
当tomcat服务器启动的时候,就创建当前类对象数值越大,优先级越小，
1:最大优先级的
<load-on-startup>1</load-on-startup>

接收前台表单提交数据

 @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
​
//解决post提交方式的中文乱码
request.setCharacterEncoding("utf-8");
//解决响应的中文乱码
response.setContentType("text/html;charset=utf-8");
​
 //tomcat版本8.0以上 无须手动方式解决get提交方式乱码,tomcat8以上已经get优化了
​
覆盖doGet和doPost方法的时候,两个方法处理get方式和post方式
接收前台参数数据的方式都是通用的,所以只需要在doPost将doGet()复用即可!
​
//通用方法:获取前台参数
//public String getParameter(String name):通过name属性值获取它提交的内容
String username = request.getParameter("username");
String passowrd = request.getParameter("password");
System.out.println(username+"----"+passowrd);
​
​
//public java.util.Enumeration<E> getParameterNames() :获取的所有的参数名称的内容
        //针对复选框:选多个值:默认获取的第一个值!
        Enumeration<String> en= request.getParameterNames();
        while(en.hasMoreElements()){
            String name = en.nextElement();//参数名称
​
            //public String getParameter(String name):通过name属性值获取它提交的内容
            String value = request.getParameter(name);
            System.out.println(name+"---"+value);
        }
​
    }
}
 @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
​
        //覆盖一下doGet即可
        doGet(request,response);
​
​
​
doPost方法中覆盖
覆盖一下doGet即可
doGet (request, response);

 

Day2

获取ServletConfig配置对象

ServletConfig对象:是Servlet的配置对象
​
获取ServletConfig对象:
GenericServlet:抽象的父类中:
public ServetConfig getServietConfig(){return this.config}
​
//ServletConfig:获取配置参数
ServletConfig config = this.getServletConfig();
​
//String getInitParameter(String var1);//参数名称获取参数值
String value = config.getInitParameter("web.xml文件中配置的名称");
​
​
//public java.util.Enumeration<E> getInitParameterNames():获取servlet的所有初始化参数名称
        Enumeration<String> ens = config.getInitParameterNames();
        while(ens.hasMoreElements()){
            String name = ens.nextElement();
            String v = config.getInitParameter(name);
            System.out.println(name+"---"+v);
        }
        
​
xml文件设置:
 <!--参数名称-->
     <param-name>名称</param-name>
     <!--参数值-->
     <param-value>参数值</param-value>
 </init-param>
 <init-param>
     <param-name>path</param-name>
     <param-value>d:/a.txt</param-value>
 </init-param>
 <load-on-startup>1</load-on-startup>

全局对象

ServletContext作用1

全局对象:ServletContext
每一个web应用程序都有自己的上下文:  工程名称,包含在url地址上
​
http://localhost:8080/***/***/***上下文路径
​
作用1:能加载全局配置参数 (读取一些配置文件)
​
html:超文本标记语言,
书写html标签:移动存在的标签
​
xml:可扩展标记语言(早期用来替代html语言,没有成功)(作为配置文件使用)
非常注重结构(又开始有接收)
作为小型数据库
用户可以自定义标签
特点:一个xml文件只能有一个根标签 
​
作用1:能加载全局配置文件()
​
在xml文件中配置全局参数
 <!--全局参数-->
    <context-param>
        <param-name>AAA</param-name>
        <param-value>AAA'value</param-value>
    </context-param>
    
获取:
1)通过ServletContext对象,获取全局参数
​
抽象的父类中
public ServletContext getServletContext() {
return this.getServletConfig().getServletContext();
​
ServletContext context = this.getServletContext();
​
//    String getInitParameter(String var1);:初始化的全局参数
String value = context.getInitParameter("AAA");//参数名称获取参数内容
System.out.println(value);

ServletContext作用2

ServletContext:可以获取上下文路径
​
 //1)获取Servletcontext对象
ServletContext servletContext = this.getServletContext(); //全局对象
//2)String getContextPath():获取上下文路径
String path = servletContext.getContextPath();
System.out.println(path);
​
Http协议:将获取上下文路径的方法,封装在请求对象中
​
String path = request.getContextPath();
System.out.println(path);
​
​
pageContext
getReuqest()---->Request对象
request--->称为 pageContext的bean属性(javabean导航)
​
HttpServletRequest
public String getContextPath()    getXXX() ----xXX:就称为bean属性
contextPath--->称为HttpServletRequest的bean属性

ServletContext作用3

作用3:servletContext可以作为"域对象"去使用!
 
域对象:可以在不同的servlet之间进行数据共享!

与对象中通用的方法:
ServletContext:全局对象
​
将存储的obj绑定在属性名称name上,存储在web容器中
setAttribute(String name,Object obj)//给域对象中存储数据
​
getAttribute(String name)—--->0bject obj//从域对象中获取数据
​
removeAttribute (String name)//从域对象中移除内容!
​
jsp:Java Server Page(是一个模板引擎(通过特殊标签进行数据渲染))
本质就是一个Servlet
域对象:就是可以在多个Servlet之间进行数据共享!
​
​

 //获取全局对象
 ServletContext servletContext = this.getServletContext();
 //给当前域对象添加属性和内容
 //void setAttribute(String var1, Object var2);
 List<String> list = new ArrayList<String>() ;
 list.add("张三") ;
 list.add("李四") ;
 list.add("王五") ;
​
servletContext.setAttribute("list",list);//存储的属性名称 "见名知意"
System.out.println("保存成功...");
​
​
//-----
在第二个servlet中
​
 //获取全局对象
 S ervletContext servletContext = this.getServletContext();
 // Object getAttribute(String var1);//可以存储任意java类型
 List<String> list = (List<String>) servletContext.getAttribute("list");
 for(String str:list){
 System.out.println(str);
 }
 System.out.println("获取成功....");

常见的域对象:从小到大

PageContext   page域:jsp页面中使用(当前jsp页面中有效)
​
HttpServletRequest request对象(是一次请求中有效)
​
HttpSession session对象(在一次会话中有效)
​
ServletContext  application域(在整个web工程下有效)

ServletContext作用4

请求转发
原理:
​
将文件放在WEB-INF下只能通过请求转发的方式 访问,其他方式不能访问!属于服务器行为,不需要带上下文路径,只需要"/"开头带上地址
1)获取全局对象
ServletContext servletContext = this.getServletContext();
2)获取分发对象
RequestDispatcher getRequestDispatcher(String var1)
​
// 参数:客户端发送的请求 通过分发对象访问服务器的内部资源文件(servet,jsp,html)
//服务器行为:通过服务器进行内部转发  路径: 无需带(工程路径)上下文路径,需要"/"开头
​
RequestDispatcher rd =
        servletContext.getRequestDispatcher("/WEB-INF/hello.html");
//void forward(ServletRequest var1, ServletResponse var2)转发到上面的地址上
rd.forward(request,response);
HttpServletRequest
HttpServletResponse
子实现类
HttpServletRequestWrapper
HttpServletResponseWrapper       

简写方式:
在ServletRequest接口中存在一个方法:可以直接获取分发对象
RequestDispatcher getRequestDispatcher(String var1); 获取分发对象
request.getRequestDispatcher("/get.jsp").forward(request,response)

请求转发特点

两次请求的request对象是相同的一个对象(请求转发最大的特点)
​
请求转发:如果业务数据获取到了,在jsp页面使用这个业务数据就用请求转发(request作为域对象)
​
​
浏览器输入:http:/ / localhost:8080/EE_day36_war/demo3
(第一次请求)
访问url-pattern为demo3的servlet反射调用doGet()方法
1)获取分发对象:RequestDispatche
​
通过forward转发
rgetRequestDispatcher("/adv.html/xx.jsp").forward(request, response)
​
(第二次请求(服务器内转发))
web容器:分发对象请求服务器,方位adv.html
在web目录有一个adv.html,通过分发对象进行请求 ,最终相应结果

RR:Request/Resopnse

浏览器输入网址访问服务器
服务器解析数据,获取请求相关的参数数据
浏览器发送请求:request
服务器想用对象:response

浏览器规定

无论是什么浏览器,HTTP协议规定,发送信息的组成(请求行+请求头)
请求行
    请求头提交方式及  URI  Http协议版本1.1
    
请求头
key : value组成请求头:内容
user-agent:chrome谷歌浏览器
host : localhost : 8080(主机地址)
​
​
http协议规定:不同的服务器统一规范的响应内容
组成:
响应行 
    http协议版本1.1
    响应状态码
响应头  key :value组成
​
refresh:定时刷新头
        经过多少秒之后完成页面跳转
​

重定向特点

重定向:后台跳转页面的一种方式
原理:使用响应头:location,再加上一个响应的状态码:302O(表示再一次请求)
​
重定向的两次request对象不同,使用重定向一般都是仅仅作为后台跳转!
而请求转发:request对象相同,所以他有业务数据,后台跳转时是可以获取到在request域中存储的数据!
​
重定向仅用于页面跳转,重定向无法访问WEB-INF下的资源文件,
                    WEB-INF下的资源文件只能通过请求转发来访问!
​

浏览器内输入网址第一次请求(request)服务器
​
服务器端设置它的响应头location以及status:状态码
​
响应对象.setHeader("location", request.getContextPath()+" /adv.html") ;
响应对象.setStatus (302) ;
​
解析内容响应(response)给浏览器
通过浏览器查看
response Header:响应头内容
Http1.1 302
location:WEB/ adv. html  (xx.jsp)
​
浏览器获取服务器响应的参数:302以及locaiton会再一次发送请求,请求当前项目下的adv.html
此时会再次请求服务器,(第二次请求(request))此时两次的request不一致了
​
重定向仅用于页面跳转
​
服务器响应成功(adv.html状态码:200)3
​

 

重定向原理(属于浏览器行为:需要带上下文路径)
设置响应头:location头
void setHeader(String var1, String var2);
 // response.setHeader("location",request.getContextPath()+"/adv.html");
     //设置响应状态码
     // void setStatus(int var1);
     response.setStatus(302); //再次发送请求*/
        
//优化:
    //在响应对象:ServletRseonse中
    //void sendRedirect(String var1) throws IOExceptio
    response.sendRedirect(request.getContextPath()+"/adv.html");//动态获取文件

响应头

响应头:
    定时刷新头:refresh
    有定时刷新和经过多少秒后进行页面跳转

//response.setHeader("refresh","3");//每3秒页面刷新
​
//经过多少秒后进行页面跳转
response.getWriter().write("注册成功!3秒后跳转主页");
        response.setHeader("refresh","3;"+request.getContextPath()+"/index.jsp");

注解

注解的本质就是一个接口:interface
    当前接口中的方法名----在注解中叫属性"
​
使用注解就不能使用xml文件
​
jdk提供很多内置注解,内置注解中会使用到一些元注解
​
@Override: 标记某个方法是否是否重写的方法(重写的类还是重写接口的方法)
@Deprecated:标记某个方法是否是过时的
@FunctionalInterface :标记某个接口是否是函数式接口
@SuppressWarnings:压制警告  (项目部署上线的时候:代码不能出现黄色警告线问题)
 
内置注解中会依赖于元注解
@Target:标记当前内置注解能够在哪个范围上使用
public @interface Target {
 
             ElementType[] value();        返回值类型:枚举数组
             ElementType:    枚举规定的范围
             TYPE,       类/接口上使用
             FIELD,      成员变量上使用
             METHD       成员方法上使用
         }
​
@Retention:规定的注解的保留阶段(三个阶段)
public @interface Retention {
        RetentionPolicy value();
 }
 
 RetentionPolicy:枚举
         SOURCE, 编译阶段
         CLASS,  类的加载阶段
         RUNTIME 运行阶段   (我们自定义注解的时候:考虑运行阶段)
         
         
 @Documented:文档相关的注解        
         
注解中的属性----接口的方法名
 
      定义注解中的属性的类型可以分为哪些?
 
               String类型
枚举类型
              注解类型
               以上类型的数组方式
注意事项:
    如果当前注解有且仅有一个属性的时候,并且名称value,那么给value属性是可以省略名称value,直接返类型赋值

解析自定义注解

jdk提供的内置注解或者他们依赖的元注解 或者开发者自定义的注解都继承自己公共接口 Annotation
​
//使用注解优化:好处将相关的属性信息定义在注解中---通过反射执行
//如何解析自定义注解呢?反射的方式完成
//注解作用在哪个类上,获取当前字节码文件对象
​
/解析注解
//Class类中public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
//参数为:当前注解类型的字节码文件对象
//返回值:相当于获取到了MyAnnotation注解(接口)获取子实现类对象
​
MyAnnotation myAnnotation = (MyAnnotation) clazz.getAnnotation(MyAnnotation.class);
String className = myAnnotation.className(); //调用方法(注解中的属性)
String methodName = myAnnotation.methodName();
​
//通过Class.forName(className)
Class myClazz = Class.forName(className);
//System.out.println(myClazz);//class com.qf.annotation_05.Student
//直接创建该类实例
Object obj = myClazz.newInstance();
//        System.out.println(obj);
​
//myClazz获取成员方法Method
Method method = myClazz.getMethod(methodName);
//调用
method.invoke(obj) ;

jsp脚本注释

jsp脚本注释 是不会被解析的
而html注释:是会被解析
jsp:Java Server Page :Java服务页面(能够书写java代码的html页面)
​
jsp应用场景:主要通过servlet获取业务数据,在jsp做数据展示的!
​
jsp经历两个阶段           ----- 由web容器来完成
    1)翻译阶段
            hello.jsp----->翻译成hello_jsp.java文件
​
    2)编译阶段
            hello_jsp.java---->通过jvm 进行编译hellDo_jsp.class

 

Day3

page指令

 属性:
 
<%@ page contentType="text/html;charset=UTF-8" language="java"  pageEncoding="UTF-8"
         isELIgnored="true"  session="true" autoFlush="true"   import="java.util.*"  buffer="8kb" %>
         
         contentType:指定响应的编码格式
         language:jsp支持java语言
         buffer:缓冲区大小 默认指定8kb  (需要给浏览器写入内容)
            需要借助流对象:JspWriter
         import:导入相关的包
         session:
            true:表示已经存在会话了 (自己使用:true)
            false:(不是禁用会话),阻止jsp和后台servlet之间针对没有产生用户的会话
            高流量的网站,session设置为false,可以大大节省的服务器的内存空间!
​
            autoFlush：true 开启自动刷新
            isELIgnored:是否忽略el表达式
                            true(忽略)
                            false:不忽略   
            pageEncoding:当前页面编码格式

jsp注释
HttpSession:域对象﹑浏览器和服务器之间的产生的会话存储起来(用户相关的信息)setAttribute ( "name"，"张三")
​
获取HttpSession:
​
​
web容器servlet--提供注解:@WebServlet
​
​
loadOnStartup:配置servlet初始化时机数字越大优先级越小
​

当前注解中的属性name指定 serlvet-name ,可以省略不写,默认当前类名
 urlPatterns:指定映射路径  数组:一般指定一个路径即可!
               /user/login
               /user/register
 loadOnStartup:配置servlet初始化时机  数字越大优先级越小
​
//@WebServlet(urlPatterns = "/servletDemo")
@WebServlet(value = "/servletDemo")
​
​
​
//创建session
//如果第一次使用:就是创建
public HttpSession getSession():创建session
HttpSession session = request.getSession();
//存储内容
session.setAttribute("name","张三");
​
//Session的范围比request范围: 在一次会话中有效!

includ指令

inlucde指定:静态包含
用法:<%@ include file="路径.jsp"%>
​
file可以包含任意的jsp页面:
    公共jsp页面被其他页面共用的时候,就可以使用静态包含(不会将被包含进来的jsp页面单独进行翻译和编译)
    特点:
        节省内存空间
        只是将被包含的jsp页面的内容加载进来!
        共用的导航栏以及底部导航栏都可以使用@include指令静态包含

targlib指令

 1)导包:
     jstl核心包 :jstl-1.2.jar
     standard-1.1.2.jar 标准包
 2)在jsp页面上使用targlib指令
     <%@targlib prefix="c" uri="" %>
     <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
3)就可以使用c标签
    c:标签名称   
4)前提条件要使用核心标签库,--->使用el表达式
    el表达式${}替代jsp输出表达式

 //给request域对象中存储String数据  <%%>
 
// 输出表达式获取request域对象存储的数据  <%= %>
​
​
/给request域对象中存储String数据
pageContext.setAttribute("user","张三");
request.setAttribute("user","admin");       //相当于给Map集合中添加key,value
session.setAttribute("user","杨德财") ;
application.setAttribute("user","高圆圆");
String username = (String) request.getAttribute("user");  
​
​
 ${域对象.属性名称}
  //   域对象:
         el中使用域
         内置对象
         pageScope          page域                   pageContext
         requestScope       request域                HttpServletRequest
         sessionScope       session域                HttpSesison
         applicationScope   application域            ServletContext
         
// 通过域对象.属性即可    本质就是返回Map集合
​
${requestScope.user} //指定域访问属性
​
${user}  //不指定域,谁小谁先访问
//在${el内置对象.属性名称} 优化,不需要书写域对象
//不需要书写内置对象      直接这样写
//${属性名称}
//在四个域对象中搜索哪一个域对象中绑定了user属性---获取内容,谁小谁先取到
//---->findAttribute(String name)

javaBean

javaBean是一种规范:
1)当前类是一个具体类
2)有私有字段private修饰
3)提供setXXX()getXXX()方法
4)当前类如果需要在网络中传输,实现序列化接口:serializable

//jsp页面中:javabean导航
//通过el表达式 可以直接调用getXXX()方法
//XXX---称为当前类的bean属性
​
//getXXX() 获取内容的/setXXX()赋值的
// el表达式: ${域对象中存储属性.xXX}
​

 el表达式来操作 javabean属性
 
 //创建User对象
 User user = new User() ;
​
//赋值
user.setUsername("高圆圆");
user.setPassword("123456");
//将user对象存储request域中
request.setAttribute("user",user);
​
<%--通过el表达式操作bean属性
 ${user}  ---->    (User)(request.getAttribute("user")) ---->User
--%>
${user.username}  -  ${user.password}

核心标签库

-导入taglib指令uri="jstl的核心库core"
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
​
c:if标签 提供判断逻辑使用
    test属性
            使用${}判断     如果结果为true,则执行c:if语句体;否则不执行
​
    c:if标签针对某种条件进行判断,没有c:else标签;如果需要在判断:在使用c:if

<%
    User user = new User() ;
    user.setUsername("zhangsan");
    user.setPassword("123456");
​
    //request域对象中
    request.setAttribute("user",user);
%>
    <c:if test="${user.username.equals('zhangsan')}">
        用户名一致
    </c:if>
    <c:if test="${!user.username.equals('zhangsan')}">
            对不起,用户名存在问题
</c:if>

c:choose

 核心标签库中提供 选择结构语句
    c:choose
    c:when  test="${xxx}"      匹配结果
    c:otherwise:上面c:when都不匹配的结果
    <c:choose>
        <c:when test="">
​
        </c:when>
        <c:when test="">
​
        </c:when>
​
        <c:otherwise>
​
        </c:otherwise>
    </c:choose>
    
<%
    int number = 5 ;
    //给request域对象中存储了number值
    request.setAttribute("number",number);
%>
​
<c:choose>
    <c:when test="${number==1}">星期一</c:when>
    <c:when test="${number==2}">星期二</c:when>
    <c:when test="${number==3}">星期三</c:when>
    <c:when test="${number==4}">星期四</c:when>
    <c:when test="${number==5}">星期五</c:when>
    <c:when test="${number==6}">星期六</c:when>
    <c:when test="${number==7}">星期日</c:when>
    <c:otherwise>
        <strong>对不起,非法数据!</strong>
​
    </c:otherwise>
</c:choose>

c:foreach标签

方式1

c:foreach标签两种用法
普通方式:
    类上于java代码普通for循环的格式
​
        属性:
        begin:当前起始角标
        end:结束角标(包含结束角标值的)
        step:步长语句
        var:循环中的变量名
        varStatus:循环中的状态
        varStatus="status"
​
        status.index:访问角标(从0开始)
        status.count: 序号:从1开始

脚本代码内不能写标签
<c:forEach begin="0" end="10" var="i" step="1" varStatus="status" >
        <%--
        取值:el表达式
        --%>
        ${status.count}  -  ${i}  <br/>
</c:forEach>
    
begin:从0开始
end:到10结束
var:变量i
step:每次＋1
varStatus:循环状态,序号

方式2

跟业务相关的使用方式:  需要从后台获取域对象中存储的数据
items属性:
    c:foreach
        items = "${list}"   var :循环中的变量
        varStatus:循环中的状态

<%
        //创建List集合
        List<String> list = new ArrayList<String>() ;
        //添加数据
        list.add("JavaEE") ;
        list.add("Python") ;
        list.add("Web") ;
        list.add("C") ;
​
        //将list集合存储到request域中
        request.setAttribute("list",list);
%>
​
<c:forEach items="${list}" var="p" varStatus="status">
​
    ${status.count} - ${p}  <br/>
</c:forEach>

MVC:架构设计思想

M:Model数据模型(业务模型数据)
v : View视图
C:Controller:控制器
​
​
实体类--—-->entity/domain/pojo
控制器放置包--->web/controller
业务模型
    业务接口层:--->service
    业务接口实现层---->service.impl
数据库访问接口层---->dao
数据库访问接口实现层---->dao.impl
工具类---->dao.utils/common
​
​
1)浏览器访问服务器:展示登录页面
用户输入用户和密码,需要表单提交form action="后台地址”
​
controller/web
2)xxxServlet            AdminServlet 
接收用户相关的信息用户名和密码
调用service层通过方法查询
​
将用户可以存储在域对象中 HttpSession(用户名放在session中)
请求转发到jsp页面上
​
​
3) service
    UserService接口
        User findUser(用户的数据);
​
4)service.impl
    UserServiceImpl
        User findUser(String name,String password){
        //调用dao层:数据库访问层
        (在service调用AdminServlet,service通过User findUser(用户的数据);接口实现  )
​
        业务层调用User selectUserByUserName
                    (String name,String password);,业务层返回结果
}
​
5)dao数据库访问接口
    UserDao
    User selectUserByUserName(String name,String password);
    
    dao.imp1接口实现层UserDaoImpl
    User selectUserByUserName (String name,String password){
    
    //原生JDBC操作
    //apache的开源工具库去操作
    return user;
​

Day4

UUID

UUID: java.util一个工具可以每次产生一个随机的字符:每次产生32个字符
randomUUID():产生一个唯一标识符

UUID uuid = UUID.randomUUID();
String string = uuid.toString();
System.out.println(string);  //每次输出的都不一致(是唯一的):
                        //ff77aa0a-766b-4799-9f77-780b991fb436
​

响应式属性

添加响应式属性:
防止浏览器分别尺寸不断的进行变化,内容不会紊乱(自动适应屏幕分辨率)
<div class="table-responsivet>
    <table class="table">
    ...
    </table>
</div>
​

禁用超链接跳转

禁用掉javascript : void(O)
<a href=" javascript:void(0)" ><a/>

Maven

Maven:是一款项目管理工具软件
通过一小段信息描述:管理jar文件(一个jar包:存储很多核心第三方类以及接口...)

配置环境变量

在环境变量里添加MAVEN_HOME,
path中添加%MAVEN_HOME%\bin
​
配置完成后在dos窗口查看maven版本:mvn -ersion
​
可以针对某个maven项目进行清除,编译,打包.安装部署
​
mvn-clear(清除之前的项目)
mvn -compile(重新编译)
mvn -package(打包)
mvn -install(安装)
mvn -deploy(部署)
​
idea/eclipse开发工具:对maven工具软件/git/svn都集成好了
                            git和svn(版本控制工具）代码的版本
​
​
有了maver还需要下载本地仓库

maven的conf目录配置

打开conf目录中的setting. xml
​
1)需要关联本地从仓库地址
在<settings>下添加
<!--本地仓库配置-->
<localRepository>repository_personal文件地址</localRepository>
​
2)配置ailiyun的仓库
如果maven项目关联的jar包本地仓库如果没有aliyun的仓库下载
<!--配置alimaxen镜像--><mirror>
        <id>alimaven</id>
            <name>aliyun maven</name>
            <url>https : //maven.aliyun.com/repository/public</ur>
            <mirrorOf>central</mirrorOf>
        </mirror>   
​
3)配置maven内部的编译环境
<!--maven编译环境-->
     <profile>
      <id>jdk-1.8</id>
      <activation>
      <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
      </activation>
      <repositories>
        <repository>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        </repository>
      </repositories>
    </profile>


maven项目中:如果配置好了本地仓库地址
就可以pom. xml
<!--导入依赖的jar包--><dependencies>
导入本地仓库中相关的jar包用谁导入谁
</dependencies>

maven与普通的web工程有什么区别?

普通的web工程
src:放置原码
web目录:存放资源文件
WEB-INF
web. xm1当前web工程的全局配置文件
导入的第三方的jar包
弊端:
1)随着项目不断的进行扩展, jar包会越来越多,造成web工程内存越来越多
2)当前jar包版本更新了,需要将原来的jar包解绑,然后在重新绑定新的jar包项目下维护起来麻烦!


idea创建maven项目大大节省内存空间,而且jar包的版本事新便于维护idea创建maven项目
网络条件好的话创建maven是可以选择在线骨架,也可以不选择后期手动补全项目结构
​