My Java 总结
一、面向对象的编程语言的特征
面向对象的编程语言有封装、继承 、抽象、多态等4个主要的特征。
1封装：封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
2.抽象：抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，
如下： class Person{ String name; int age; } 人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。
3. 继承：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
4.多态：多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由daofactory.getDao()在执行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修改源代码，就可以改变userDao指向的具体类实现，从而导致userDao.insertUser()方法调用的具体代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法： UserDao userDao = daofactory.getDao(); userDao.insertUser(user);
面向对象编程有三大特性：封装、继承、多态。
封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。
继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。，同时继承也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？请看我一一为你揭开：
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：
酒 a = 剑南春
酒 b = 五粮液
酒 c = 酒鬼酒
…
这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。
诚然，要理解多态我们就必须要明白什么是“向上转型”。在继承中我们简单介绍了向上转型，这里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父类，剑南春（JNC）、五粮液（WLY）、酒鬼酒（JGJ）是子类。我们定义如下代码：
JNC a = new JNC();
对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛！但是这样呢？
Wine a = new JNC();
在这里我们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。由于JNC是继承与Wine，所以JNC可以自动向上转型为Wine，所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，它可以提供比父类更加强大的功能，如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。
但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在与子类中的方法和属性它就望尘莫及了---1。
publicclassTestWine {
publicstaticvoidmain(String[] args) {
Wine a = newJNC();
a.fun1();
Wine b = newWine();
b.fun1();
JNC c = newJNC();
c.fun1();
}
publicstaticclassWine {
publicvoidfun1(){
System.out.println("Wine 的Fun.....");
fun2();
}
publicvoidfun2(){
System.out.println("Wine 的Fun2...");
}
}
publicstaticclassJNC extendsWine{
/* * @desc 子类重载父类方法
*父类中不存在该方法，向上转型后，父类是不能引用该方法的
* @returnvoid
*/
publicvoidfun1(String a){
System.out.println("JNC 的 Fun1...");
fun2();
}
/**
* 子类重写父类方法
* 指向子类的父类引用调用fun2时，必定是调用该方法
*/
publicvoidfun2(){
System.out.println("JNC 的Fun2...");
}}}
运行结果：
Wine 的Fun..... JNC 的Fun2... Wine 的Fun..... Wine 的Fun2... Wine 的Fun..... JNC 的Fun2...
从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。
分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。
所以对于多态我们可以总结如下：
指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。
对于面向对象而已，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。
多态的实现
2.1实现条件
在刚刚开始就提到了继承在为多态的实现做了准备。子类Child继承父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类Father对象，也可以处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。
Java实现多态有三个必要条件：继承、重写、向上转型。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
2.2实现形式
在Java中有两种形式可以实现多态。继承和接口。
2.2.1、基于继承实现的多态
基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。
publicclassTestWine2 {
publicstaticvoidmain(String[] args) {
//定义父类数组
Wine[] wines = newWine[2];
//定义两个子类
JNC jnc = newJNC();
JGJ jgj = newJGJ();
Wine wine=newWine();
//父类引用子类对象
wines[0] = jnc;
wines[1] = jgj;
for(inti = 0 ; i < 2 ; i++){
System.out.println(wines[i].toString() + "--" + wines[i].drink());
}
System.out.println("-------------------------------");
System.out.println(jnc.toString() + "--" + jnc.drink());
System.out.println(jgj.toString() + "--" + jgj.drink());
}
publicstaticclassWine {
privateString name;
publicString getName() {
returnname;
}
publicvoidsetName(String name) {
this.name = name;
}
publicWine(){
}
publicString drink(){
return"喝的是 " + getName();
}
/**
* 重写toString()
*/
publicString toString(){
returnnull;
}
}
publicstaticclassJNC extendsWine{
publicJNC(){
setName("JNC");
}
/**
* 重写父类方法，实现多态
*/
publicString drink(){
return"喝的是 " + getName();
}
/**
* 重写toString()
*/
publicString toString(){
return"Wine : " + getName();
}
}
publicstaticclassJGJ extendsWine{
publicJGJ(){
setName("JGJ");
}
/**
* 重写父类方法，实现多态
*/
publicString drink(){
return"喝的是 " + getName();
}
/**
* 重写toString()
*/
publicString toString(){
return"Wine : " + getName();}}}
在上面的代码中JNC、JGJ继承Wine，并且重写了drink()、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不同的对象可以执行相同的行为，但是他们都需要通过自己的实现方式来执行，这就要得益于向上转型了。
我们都知道所有的类都继承自超类Object，toString()方法也是Object中方法，当我们这样写时：
Object o = newJGJ();
System.out.println(o.toString());
输出的结果是Wine : JGJ。
Object、Wine、JGJ三者继承链关系是：JGJ—>Wine—>Object。所以我们可以这样说：当子类重写父类的方法被调用时，只有对象继承链中的最末端的方法才会被调用。但是注意如果这样写：
Object o = newWine();
System.out.println(o.toString());
输出的结果应该是Null，因为JGJ并不存在于该对象继承链中。
所以基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。
如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。
2.2.2、基于接口实现的多态
继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。
在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。
继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
十二、Java EE体系架构
java EE（Java Plantfor Enterprise Edition）是sun公司推出的企业级应用程序版本。这个版本以前成为J2EE.能够帮助我们开发和部署可移植、健壮、可伸缩且安全的服务器端java应用程序。java EE 是在java SE的基础上构建的，它提供Web服务、组建模型、管理和通信API，可以用来实现企业级的面向服务体系结构和Web 2.0应用程序。
J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。
java EE 的体系结构：
1、表示层（HTML、JavaScript、Ajax）
2、中间层（JSP、Servlet、JSTL、JavaBean）（Struts）
3、数据层（JDBC）（Hibernate）
三层体系结构的优点？
1、耦合性低 2、扩展性好 3、复用性好 4、便于分工
j2ee常用的设计模式：
Java中的23种设计模式：
Factory（工厂模式）， Builder（建造模式）， Factory Method（工厂方法模式），
Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），
Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），
Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），
Observer（观察者模式）， State（状态模式）， Strategy（策略模式），
Template Method（模板方法模式）， Chain Of Responsibility（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，
通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要
定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同
的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
HTTP协议的提交方式：
1、GET——用URL传递数据
2、POST——用流的方式传递数据
Servlet是一个java程序，是在服务器端运行的以处理客户端请求并做出响应的程序。
Servlet类一定要继承HttpServlet，Servlet必须和Servlet容器配合运行，Servlet要嵌入容器才能运行。
Web应用程序的结构：
tomcat—webapps—appName：
http：//ip：port/appName/index.jsp
1、页面和图片（可以自己组织结构，可以从客户端直接访问，jsp、html、js、jpg.....)
2、WEB-INF 目录（必须有的 其中的东西不能从客户端直接访问 ）
a、web.xml （必须有 Web程序的总体配置，是一个核心）
b、classes文件夹（必须的 Servlet和JavaBean编译成Class后存放于该文件夹）
c、lib文件夹（存放该程序用的类库jar包）
Web .xml中要对Servlet进行一些配置
<Servlet>
<servlet-name>test</servlet-name>
<servlet-class>org.owl.servlets.TestServlet</servlet-class>
</Servlet>
<servlet-mapping>
<servlet-name>test</servlet-name>
<url-pattern>/test</url-pattern>
</servlet-mapping>
JSP在运行时需要翻译成一个Servlet程序，然后再编译成Class文件，然后才可以运行。
Servlet的生命周期由Servlet容器来管理
Servlet的声明周期：
1、加载和实例化（构造方法）: 在Web容器中查找用户请求的Servlet，如果没有找到，则实例化，如果找到，则加载。
2、初始化（init）:在实例化后调用的方法，可以初始化一些资源。
3、服务（service）: 接受请求并做出响应。根据请求的方式不同，调用doXXX方法。
4、销毁（destory）: 主要用来销毁初始化时创建的资源，在destory方法中我们标识哪些资源可以回收，并不能马上回收。
如何获得请求参数？
1. request。getParameter(“name”);
2. 如果一个请求参数有多个值，需要返回一个数组！
String []size=request.getParameter（“name”）；
For(int i=0;i<size.length;i++){
out.print(size[0]);
}
除了参数，还可以获得其他--
1与请求相关的cookie Cookie [] cookies=request.getCookies();
2与会话相关的session Session session=request.getSession();
3请求的HTTP方法 String methed=request.getMethed();
初始化参数：
在web.xml中设置servlet初始化参数
<servlet>
<servlet-name> dbinit </servlet-name>
<servlet-class> strutsfinalcase.db.util.DBInit </servlet-class>
<init-param>
<param-name> driverClass </param-name>
<param-value> org.gjt.mm.mysql.Driver </param-value>
</init-param>
<servlet>
解释：容器初始化一个servlet时，会为这个servlet创建一个唯一的ServletConfig， 容器从DD读出servlet初始化参数，交给ServletConfig 然后转递给servlet的init()方法
在servlet 代码中获得初始化参数的值：
getServletConfig(),getInitParameter(“param-name”);
上下文初始化参数
<context-param>
<param-name>name</param-name>
<param-value>John</param-value>
</context-param>
在servlet 代码中获得上下文初始化参数的值：
getServletContext().getInitParameter(“name”);
ServletContext
用于在Web应用范围内存取共享数据的方法。
注：web应用范围具有以下两层含义：
（1）表示有web应用的生命周期构成的时间段.
（2）表示在web应用的生命周期内所有web组件的集合。
* setAttribute(String name,java.lang.Object object)：把一个java对象和一个属性名绑定，并存放到ServletContext中，参数name指定属性名，参数Object表示共享数据。
* getAttribute(String name)：根据参数给定的属性名，返回一个Object类型的对象。
* getAttributeNames()：返回一个Enumeration对象，该对象包含了所有存放在ServletContext中的属性名。
* removeAttribute(String name)：根据参数指定的属性名，从servletContext对象中删除匹配的属性。
访问当前Web应用的资源
* getContextpath（）:返回当前web应用的URL入口。
* getInitParameter(String name)：返回web应用方位内的匹配的初始化参数值。
在web.xml中<web-app>元素中<context-param>元素表示应用范围内的初始化参数。
* getInitParameterNames()：返回一个Enumeration对象。
* getServletContextName()：返回web应用的名字。即<web-app>元素中<display-name>元素的值。
* getRequestDispatcher(String path)：返回一个用于向其他web组件转发请求的RequestDispatcher对象。
web.xml文件
web.xml文件是用来初始化配置信息：比如Welcome页面、servlet、servlet-mapping、filter、listener、启动加载级别等
1、指定欢迎页面，例如：
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index1.jsp</welcome-file>
</welcome-file-list>
PS：指定了2个欢迎页面，显示时按顺序从第一个找起，如果第一个存在，就显示第一个，后面的不起作用。如果第一个不存在，就找第二个，以此类推。
2、命名与定制URL。我们可以为Servlet和JSP文件命名并定制URL,其中定制URL是依赖命名的，命名必须在定制URL前。下面拿serlet来举例：
(1)、为Servlet命名：
<servlet>
<servlet-name>servlet1</servlet-name>
<servlet-class>org.whatisjava.TestServlet</servlet-class>
</servlet>
(2)、为Servlet定制URL、
<servlet-mapping>
<servlet-name>servlet1</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
3、定制初始化参数：可以定制servlet、JSP、Context的初始化参数，然后可以再servlet、JSP、Context中获取这些参数值。
下面用servlet来举例：
<servlet>
<servlet-name>servlet1</servlet-name>
<servlet-class>org.whatisjava.TestServlet</servlet-class>
<init-param>
<param-name>userName</param-name>
<param-value>Daniel</param-value>
</init-param>
<init-param>
<param-name>E-mail</param-name>
<param-value>125485762@qq.com</param-value>
</init-param>
</servlet>
经过上面的配置，在servlet中能够调用getServletConfig().getInitParameter("param1")获得参数名对应的值。
4、指定错误处理页面，可以通过“异常类型”或“错误码”来指定错误处理页面。
<error-page>
<error-code>404</error-code>
<location>/error404.jsp</location>
</error-page>
-----------------------------
<error-page>
<exception-type>java.lang.Exception<exception-type>
<location>/exception.jsp<location>
</error-page>
5、设置过滤器：比如设置一个编码过滤器，过滤所有资源
<filter>
<filter-name>XXXCharaSetFilter</filter-name>
<filter-class>net.test.CharSetFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>XXXCharaSetFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
6、设置监听器：
<listener>
<listener-class>net.test.XXXLisenet</listener-class>
</listener>
7、设置会话(Session)过期时间，其中时间以分钟为单位，假如设置60分钟超时：
<session-config>
<session-timeout>60</session-timeout>
</session-config>
8．设置上下文初始化参数(对于整个web应用都适用)
<context-param>
<param-name>foo</param-name>
<param-value>bar</param-value>
</context-param>
在servlet中获取上下文参数初始化String s=getContex().getInitParameter(＂ｆｏｏ＂);
3.重定向和请求分派的比较
<1>请求分派只能将请求转发给同一个web应用中的其他组件，而重定向不仅可以定向到当前应用程序中的其他资源，也可重定向到其他站点的资源上
<2>重定向的访问过程结束后，浏览器的地址栏显示的URL会发生改变，变成重定向的目标URL，而请求分派的浏览器地址栏保持初始的URL
<3>请求分派的发起者和被调者之间共享相同的request实例和response实例，属于同一个“请求/响应”而重定向的发起者和被调用者使用各自的request实例和response实例，各自属于独立的“请求/响应”过程。
请求转发 RequestDispatcher dis=request.getRequestDispatcher("Servlet2");
dis.forward(request, response);
重定向 response.sendRedirect("Servlet2"); //重定向到指定路径的资源
get 和post 比较
1. get是从服务器上获取数据，post是向服务器传送数据。
2. get是把参数数据队列加到提交表单的ACTION属性所指的URL中，值和表单内各个字段一一对应，在URL中可以看到。post是通过HTTP post机制，将表单内各个字段与其内容放置在HTML HEADER内一起传送到ACTION属性所指的URL地址。用户看不到这个过程。
3. 对于get方式，服务器端用Request.QueryString获取变量的值，对于post方式，服务器端用Request.Form获取提交的数据。
4. get传送的数据量较小，不能大于2KB。post传送的数据量较大，一般被默认为不受限制。但理论上，IIS4中最大量为80KB，IIS5中为100KB。
5. get安全性非常低，post安全性较高。但是执行效率却比Post方法好。
十三、Tomcat服务器
运行Java Web程序必须有相应Web容器支持，所有的动态程序代码都在Web容器中执行，Tomcat是一个web容器；
静态请求的所有代码操作都是固定的，动态请求操作的所有代码都是拼凑的；
Tomcat是有Apache软件基金会的Jakarta项目中的一个核心项目，有Apache、sun和其他一些公司及个人共同开发而成；
使用Tomcat必须有JDK的支持
Tomcat中主要文件夹：bin/conf/lib/logs/webapps/work
任何服务器都是依靠端口号进行监听的
服务器配置
（1）修改端口号——conf/server.xml
（2）配置虚拟目录——磁盘下建立文件夹、建立WEB-INF文件、复制web.xml文件，服务器端配置<Context path="/sjwin" docBase="url"/>
修改conf/web.xml文件listings中false为true，重启Apache服务
（3）配置首页——index.xxx；<welcome-file-list><welcome-file>main.htm</welcome-file></welcome-file-lis
十四、什么是C/S和B/S结构，各有什么优缺点
B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。浏览器通过Ｗeb Server 同数据库进行数据交互。 B/S结构，即Browser/Server(浏览器/服务器)结构，是随着Internet技术的兴起，对C/S结构的一种变化或者改进的结构。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现，形成所谓3-tier结构。B/S结构，主要是利用了不断成熟的WWW浏览器技术，结合浏览器的多种Script语言(VBScript、JavaScript…)和ActiveX技术，用通用浏览器就实现了原来需要复杂专用软件才能实现的强大功能，并节约了开发成本，是一种全新的软件系统构造技术。随着Windows 98/Windows 2000将浏览器技术植入操作系统内部，这种结构更成为当今应用软件的首选体系结构。显然B/S结构应用程序相对于传统的C/S结构应用程序将是巨大的进步。 B/S结构采用星形拓扑结构建立企业内部通信网络或利用Internet虚拟专网（VPN）。前者的特点是安全、快捷、准确。后者则具有节省投资、跨地域广的优点。须视企业规模和地理分布确定。企业内部通过防火墙接入Internet，再整个网络采用TCP/IP协议。 B/S最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件。只要有一台能上网的电脑就能使用，客户端零维护。系统的扩展非常容易，只要能上网，再由系统管理员分配一个用户名和密码，就可以使用了。甚至可以在线申请，通过公司内部的安全认证（如ＣＡ证书）后，不需要人的参与，系统可以自动分配给用户一个账号进入系统。
C/S又称Client/Server或客户/服务器模式。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。 C/S的优点是能充分发挥客户端ＰＣ的处理能力，很多工作可以在客户端处理后再提交给服务器。对应的优点就是客户端响应速度快。缺点主要有以下几个： C/S适用于局域网,C/S也支持广域网包括Internet，比如微软的MCSE、印度NIIT等的远程考试系统都是基于CS结构，CS最主要的特点在于能够给服务器减轻压力，而且有更高的安全性和稳定性。其数据库可以在客户端也可以在服务器端，但最大的缺点就是省级比较麻烦。随着互联网的飞速发展，移动办公和分布式办公越来越普及，这需要我们的系统具有扩展性。这种方式远程访问需要专门的技术，同时要对系统进行专门的设计来处理分布式的数据。客户端需要安装专用的客户端软件。首先涉及到安装的工作量，其次任何一台电脑出问题，如病毒、硬件损坏，都需要进行安装或维护。特别是有很多分部或专卖店的情况，不是工作量的问题，而是路程的问题。还有，系统软件升级时，每一台客户机需要重新安装，其维护和升级成本非常高。对客户端的操作系统一般也会有限制。可能适应于Win98, 但不能用于win2000或Windows XP。或者不适用于微软新的操作系统等等，更不用说Linux、Ｕnix等。 C/S 与 B/S 区别： Client/Server是建立在局域网的基础上的.Browser/Server是建立在广域网的基础上的. １．硬件环境不同: C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务. B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行 ２．对安全要求不同 C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息. B/S 建立在广域网之上, 对安全的控制能力相对弱, 面向是不可知的用户群. ３．对程序架构不同 C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑. B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.
４．软件重用不同 C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好. B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子 ５．系统维护不同 系统维护是软件生存周期中,开销大, -------重要 C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统 B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级. ６．处理问题不同 C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统 B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小. ７．用户接口不同 C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高 B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本. ８．信息流不同 C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低 B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更象交易中心
十五、SpringMVC
(1)什么是MVC (Model 模型 View 视图 Controller 控制器)?
是一种软件架构思想，将一个软件可以划分成模型、视图和控制器这样三种不同类型的模块，其中，模型用来封装业务逻辑，视图用来处理表示逻辑，控制器用来协调模型和视图（即视图发送请求给控制器，由
控制器调用相应的模型来处理；模型将处理结果发送给控制器，由控制器选择相应的视图来展现处理结果）。
模型(业务逻辑)：由java类来封装业务逻辑。
视图(表示逻辑)：由jsp来处理。
注：表示逻辑包含了数据的展现，另外，还有操作界面。
控制器: 由Servlet来处理。
(2)MVC的优点
1)方便维护：模型发生修改，不影响视图；反之，修改视图，也不影响模型。
2)方便测试：如果将业务逻辑写在servlet里面，需要部署之后才能测试，则写在java类里面，可以直接测试。
（3）什么是SpringMVC?
是一个用来简化基于MVC架构的web应用程序开发的框架。
注:SpringMVC是Spring框架的一部分。
(4) 五大组件
1)DispatcherServlet 前端控制器（相当于ActionServlet）
2)HandlerMapping 映射处理器 (请求路径与模型的对应关系)
3)Controller 处理器 (业务逻辑的处理)
4)ModelAndView (封装处理器的处理结果，有数据和视图名)
5)ViewResovler 视图解析器 (视图名跟真正的视图对象的对应关系)
step1. DispatcherServlet收到请求之后，依据HandlerMapping的配置，调用对应的Controller来处理。
step2. Controller将处理结果封装成ModelAndView对象，返回给 DispatcherServlet。
step3. DispatcherServlet依据ViewResolver的解析调用对应的视图对象（比如某个jsp）来展现处理结果。
十六、springMVC / Spring /mybatis开源框架
使用 SSM （ Spring 、 SpringMVC 和 Mybatis ）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。之前没有记录 SSM 整合的过程， 这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。 这次 ， 先说说 三大框架整合过程 。个人认为使用框架并不是很难，关键要理解其思想，这对于我们提高编程水平很有帮助。不过，如果用都不会，谈思想就变成纸上谈兵了！！！ 先技术，再思想。实践出真知。 （可通过图片水印查看博客地址）
1、基本概念
1.1、Spring
Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作ExpertOne-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。
1.2、SpringMVC
SpringMVC属于SpringFrameWork 的后续产品，已经融合在SpringWebFlow 里面。SpringMVC分离了控制器 、模型对象 、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。
1.3、MyBatis
MyBatis本是apache 的一个开源项目iBatis ,2010年这个项目由 apache softwarefoundation迁移到了googlecode并且改名为MyBatis 。MyBatis 是一个基于Java的持久层 框架。iBATIS 提供的持久层 框架包括 SQL Maps 和 Data Access Objects（DAO）MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis使用简单的XML或注解用于配置和原始映射，将接口和Java的POJOs（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。
2、开发环境搭建
3、Maven Web项目创建
4、SSM整合
下面主要介绍三大框架的整合，至于环境的搭建以及项目的创建，参看上面的博文。这次整合我分了2个配置文件，分别是 spring-mybatis.xml，包含spring和mybatis的配置文件，还有个是spring-mvc的配置文件，此外2个资源文件：jdbc.propertis和log4j.properties 。完整目录结构如下：
使用框架都是较新的版本 ：
Spring 4.0.2 RELEASE
Spring MVC 4.0.2 RELEASE
MyBatis 3.2.6
4.1、Maven引入需要的JAR包
为了方便后面说的时候不需要引入JAR包，我这里 直接给出所有需要的JAR包，这都是基本的JAR包 ，每个包的是干什么的都有注释，就不再多说了。
pom.xml
<properties>
<!-- spring版本号 -->
<spring.version>4.0.2.RELEASE</spring.version>
<!-- mybatis版本号 -->
<mybatis.version>3.2.6</mybatis.version>
<!-- log4j日志文件管理包版本 -->
<slf4j.version>1.7.7</slf4j.version>
<log4j.version>1.2.17</log4j.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<!-- 表示开发的时候引入，发布的时候不会加载此包 -->
<scope>test</scope>
</dependency>
<!-- spring核心包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- mybatis核心包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!-- mybatis/spring包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.2.2</version>
</dependency>
<!-- 导入java ee jar 包 -->
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
</dependency>
<!-- 导入Mysql数据库链接jar包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.30</version>
</dependency>
<!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.2.2</version>
</dependency>
<!-- JSTL标签类 -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- 日志文件管理包 -->
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<!-- 格式化对象，方便输出日志 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.1.41</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<!-- 映入JSON -->
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.9.13</version>
</dependency>
<!-- 上传组件包 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.9</version>
</dependency>
</dependencies>
4.2、Spring与MyBatis的整合
所有需要的 JAR 包都引入以后，首先进行Spring与MyBatis的整合，然后再进行JUnit测试，先看一个项目结构图：
4.2.1、建立JDBC属性文件
jdbc.properties （文件编码修改为 utf-8 ）
driver=com.mysql.jdbc.Driverurl=jdbc:mysql://10.221.10.111:8080/db_zslusername=demaopassword=demao#定义初始连接数initialSize=0#定义最大连接数maxActive=20#定义最大空闲maxIdle=20#定义最小空闲minIdle=1#定义最长等待时间maxWait=60000
4.2.2、建立spring-mybatis.xml配置文件
这个文件就是用来完成spring和mybatis的整合的。这里面也没多少行配置，主要的就是 自动扫描，自动注入，配置数据库 。注释也很详细，大家看看就明白了。
spring-mybatis.xml
<?xml version="1.0"encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<!-- 自动扫描 -->
<context:component-scanbase-package="com.cn.hnust"/>
<!-- 引入配置文件 -->
<beanid="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<propertyname="location"value="classpath:jdbc.properties"/>
</bean>
<beanid="dataSource"class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<propertyname="driverClassName"value="${driver}"/>
<propertyname="url"value="${url}"/>
<propertyname="username"value="${username}"/>
<propertyname="password"value="${password}"/>
<!-- 初始化连接大小 -->
<propertyname="initialSize"value="${initialSize}"></property>
<!-- 连接池最大数量 -->
<propertyname="maxActive"value="${maxActive}"></property>
<!-- 连接池最大空闲 -->
<propertyname="maxIdle"value="${maxIdle}"></property>
<!-- 连接池最小空闲 -->
<propertyname="minIdle"value="${minIdle}"></property>
<!-- 获取连接最大等待时间 -->
<propertyname="maxWait"value="${maxWait}"></property>
</bean>
<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">
<propertyname="dataSource"ref="dataSource"/>
<!-- 自动扫描mapping.xml文件 -->
<propertyname="mapperLocations"value="classpath:com/cn/hnust/mapping/*.xml"></property>
</bean>
<!-- DAO接口所在包名，Spring会自动查找其下的类 -->
<beanclass="org.mybatis.spring.mapper.MapperScannerConfigurer">
<propertyname="basePackage"value="com.cn.hnust.dao"/>
<propertyname="sqlSessionFactoryBeanName"value="sqlSessionFactory"></property>
</bean>
<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
<beanid="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<propertyname="dataSource"ref="dataSource"/>
</bean>
</beans>
4.2.3、Log4j的配置
为了方便调试，一般都会使用日志来输出信息， Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIXSyslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
Log4j 的配置很简单，而且也是 通用的 ，下面 给出一个基本的配置 ，换到其他项目中也无需做多大的调整，下面给出配置文件目录：
log4j.properties
#定义LOG输出级别
log4j.rootLogger=INFO,Console,File#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out#可以灵活地指定日志输出格式，下面一行是
指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n
#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender#指定输出目录
log4j.appender.File.File = logs/ssm.log#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n
4.2.4、JUnit测试
经过以上步骤（到4.2.2，log4j不配也没影响），我们 已经完成了Spring和mybatis的整合 ，这样我们就可以编写一段测试代码来试试是否成功了。
4.2.4.1、创建测试用表
既然我们需要测试，那么我们就需要建立在数据库中建立一个测试表，这个表建的很简单，SQL语句为：
DROPTABLEIFEXISTS`user_t`;
CREATETABLE`user_t`(
`id`int(11) NOTNULLAUTO_INCREMENT,
`user_name`varchar(40) NOTNULL,
`password`varchar(255) NOTNULL,
`age`int(4) NOTNULL,
PRIMARY KEY(`id`)
) ENGINE=InnoDBAUTO_INCREMENT=2DEFAULTCHARSET=utf8;
/*Data for the table `user_t` */
insertinto`user_t`(`id`,`user_name`,`password`,`age`) values(1,'测试','sfasgfaf',24);
4.2.4.2、利用MyBatis Generator自动创建代码
这个可根据表自动创建实体类、 MyBatis 映射文件以及 DAO 接口，当然，我 习惯将生成的接口名改为 IUserDao ，而不是直接用它生成的 UserMapper 。如果不想麻烦就 可以不改 。完成后将文件复制到工程中。如图：
4.2.4.3、建立Service接口和实现类
目录结构：
下面给出具体的内容：
IUserService.jave
packagecom.cn.hnust.service;
importcom.cn.hnust.pojo.User;
publicinterfaceIUserService{
publicUser getUserById(intuserId);
}
UserServiceImpl.java
packagecom.cn.hnust.service.impl;
importjavax.annotation.Resource;
importorg.springframework.stereotype.Service;
importcom.cn.hnust.dao.IUserDao;importcom.cn.hnust.pojo.User;importcom.cn.hnust.service.IUserService;
@Service("userService")publicclassUserServiceImplimplementsIUserService{
@Resource
privateIUserDao userDao;
@Override
publicUser getUserById(int userId) {
returnthis.userDao.selectByPrimaryKey(userId);
}
}
4.2.4.4、建立测试类
测试类 在src/test/java中建立 ，下面测试类中 注释掉的部分是不使用 Spring 时，一般情况下的一种测试方法 ；如果使用了 Spring 那么就可以使用注解的方式来引入配置文件和类，然后再将 service 接口对象注入，就可以进行测试了。
如果测试成功，表示 Spring 和 Mybatis 已经整合成功了 。输出信息使用的是 Log4j 打印到控制台。
package org.zsl.testmybatis;
importjavax.annotation.Resource;
importorg.apache.log4j.Logger;importorg.junit.Before;importorg.junit.Test;importorg.junit.runner.RunWith;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;importorg.springframework.test.context.ContextConfiguration;importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;
importcom.alibaba.fastjson.JSON;importcom.cn.hnust.pojo.User;importcom.cn.hnust.service.IUserService;
@RunWith(SpringJUnit4ClassRunner.class)//表示继承了SpringJUnit4ClassRunner类
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
publicclassTestMyBatis{
privatestaticLoggerlogger = Logger.getLogger(TestMyBatis.class);//private ApplicationContext ac = null;
@Resource
privateIUserServiceuserService = null;
//@Before//public void before() {//ac = new ClassPathXmlApplicationContext("applicationContext.xml");//userService = (IUserService) ac.getBean("userService");//}
@Test
publicvoid test1() {
Useruser = userService.getUserById(1);
// System.out.println(user.getUserName());
// logger.info("值："+user.getUserName());
logger.info(JSON.toJSONString(user));
}
}
测试结果：
至此， 完成Spring和mybatis这两大框架的整合 ，下面在继续进行SpringMVC的整合。
4.3、整合SpringMVC
上面已经完成了2大框架的整合，SpringMVC的配置文件单独放，然后在web.xml中配置整合。
4.3.1、配置spring-mvc.xml
配置里面的注释也很详细，在此就不说了，主要是 自动扫描控制器，视图模式，注解的启动 这三个。
<?xml version="1.0"encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<!--自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
<context:component-scanbase-package="com.cn.hnust.controller"/>
<!--避免IE执行AJAX时，返回JSON出现下载文件 -->
<beanid="mappingJacksonHttpMessageConverter"
class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
<propertyname="supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
</list>
</property>
</bean>
<!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<propertyname="messageConverters">
<list>
<refbean="mappingJacksonHttpMessageConverter"/><!-- JSON转换器 -->
</list>
</property>
</bean>
<!-- 定义跳转的文件的前后缀 ，视图模式配置-->
<beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
<propertyname="prefix"value="/WEB-INF/jsp/"/>
<propertyname="suffix"value=".jsp"/>
</bean>
<!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->
<beanid="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- 默认编码 -->
<propertyname="defaultEncoding"value="utf-8"/>
<!-- 文件大小最大值 -->
<propertyname="maxUploadSize"value="10485760000"/>
<!-- 内存中的最大值 -->
<propertyname="maxInMemorySize"value="40960"/>
</bean>
</beans>
4.3.2、配置web.xml文件
这里面对spring-mybatis.xml的引入以及配置的spring-mvc的Servlet就是为了完成SSM整合，之前2框架整合不需要在此处进行任何配置。配置一样有详细注释，不多解释了。
web.xml
<?xml version="1.0"encoding="UTF-8"?><web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<display-name>Archetype Created Web Application</display-name>
<!-- Spring和mybatis的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mybatis.xml</param-value>
</context-param>
<!-- 编码过滤器 -->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<async-supported>true</async-supported>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- Spring监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 防止Spring内存溢出监听器 -->
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<!-- Spring MVC servlet -->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->
<url-pattern>/</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>/index.jsp</welcome-file>
</welcome-file-list>
</web-app>
4.3.3、测试
至此已经完成了SSM三大框架的整合了，接下来测试一下，如果成功了，那么恭喜你，如果失败了，继续调试吧， 作为程序员就是不停的与BUG做斗争 ！
4.3.3.1、新建jsp页面
showUser.jsp 此页面仅输出一下用户名，完成一个 完整的简单流程 。
<%@page language="java"import="java.util.*"pageEncoding="utf-8"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html>
<head>
<title>测试</title>
</head>
<body>
${user.userName}
</body></html>
4.3.3.2、建立UserController类
UserController.java 控制器
packagecom.cn.hnust.controller;
importjavax.annotation.Resource;importjavax.servlet.http.HttpServletRequest;
importorg.springframework.stereotype.Controller;importorg.springframework.ui.Model;importorg.springframework.web.bind.annotation.RequestMapping;
importcom.cn.hnust.pojo.User;importcom.cn.hnust.service.IUserService;
@Controller@RequestMapping("/user")publicclassUserController{
@Resource
privateIUserService userService;
@RequestMapping("/showUser")
publicString toIndex(HttpServletRequest request,Model model){
int userId = Integer.parseInt(request.getParameter("id"));
User user = this.userService.getUserById(userId);
model.addAttribute("user", user);
return"showUser";
}
}
4.3.3.3、部署项目
输入地址： localhost:8080/ 项目名称 /user/showUser?id=1
至此，SSM三大框架的整合就完成了，在此基础上可再添加其他功能。
六、Tomcat安装及配置
用来进行web开发的工具有很多，Tomcat是其中一个开源的且免费的java Web服务器，是Apache软件基金会的项目。电脑上安装配置Tomcat的方法和java有些相同，不过首先需要配置好java的环境才行。
工具/原料
Tomcat7.0
eclipse
java环境的配置
下载安装java JDK，注意安装的路径，我们需要进行环境变量的配置。
安装完成以后，配置环境变量
环境变量的配置这里就以win7为例：右击计算机——属性——高级系统设置。
3
点击下面的环境变量，进入后在系统变量一栏点击新建，然后输入如下：
名称：JAVA_HOME
变量值：刚刚安装的路径
在上面的一栏中点击新建，内容如下：
名称：CLASS_PATH
变量值：.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
一定要注意所有符号都是英文状态的。
在系统环境变量中有一个path的环境变量，选中后选择编辑，将JAVA_HOME添加进去即可，如图：在最后加上;%JAVA_HOME%\bin;
测试java环境是否配置成功
按下win+R键，输入cmd调出命令符控制窗口。输入：java -version 后查看是否显示版本即可。
安装配置Tomcat
下载Tomcat文件，文件是一个exe的安装文件，下载后直接安装即可。
下载地址在百度输入Tomcat进入官网即可找到下载文件。安装文件没有什么技巧，一直点击下一步即可。
同样安装时注意安装目录，因为一会要配置和java一样的环境变量。
同样打开环境变量的配置窗口，在系统环境变量一栏点击新建。
输入内容如下：
变量名：CATALINA_HOME
变量值：刚刚安装的路径
测试安装配置是否成功
找到暗黑族昂路径下的bin 文件夹，找到里面的执行文件，运行，然后执行下面的操作。
打开浏览器，输入http：//localhost:8080.如果出现下面的内容说明成功了。
Eclipse的配置-----到Eclipse官网下载最新版的Eclipse，解压后即可，不需要安装。
运行Eclipse程序文件，打开Eclipse工作界面。
选择菜单栏中的window——preferences。
选择左侧的 server——runtime environment——在弹出的窗口中选择 add——然后选择你的Tomcat的版本即可。
选择tomcat的路径，和java的版本即可完成配置工作。
十六、Eclipse与MyEclipse
很多Java的学习者会纠结一个问题, 是采用免费的Eclipse呢还是采用破解的MyEclipse. 在讨论这个问题之前,我们先来看看他们的区别把:
Eclipse，跨平台的自由集成开发环境（IDE）。最初主要用来Java语言开发，但是目前亦有人通过插件使其作为其他计算机语言比如C++和Python的开发工具。Eclipse的本身只是一个框架平台，但是众多插件的支持使得Eclipse拥有其他功能相对固定的IDE软件很难具有的灵活性。许多软件开发商以Eclipse为框架开发自己的IDE。免费使用。
MyEclipse企业级工作平台（MyEclipse Enterprise Workbench ，简称MyEclipse）是对Eclipse IDE的扩展，也就是所说的插件，利用它我们可以在数据库和J2EE的开发、发布，以及应用程序服务器的整合方面极大的提高工作效率。它是功能丰富的J2EE集成开发环境，包括了完备的编码、调试、测试和发布功能，完整支持HTML, Struts, JSF, CSS, Javascript, SQL, Hibernate。可惜就是收费。
很明显,两者定位不同. 免费 VS 收费, 当然收费的肯定比免费的好用。事实也的确如此. 但是作为Java的学习者.我个人建议在学习Java的过程中尽量使用Eclipse.原因如下:
1: 对Eclipse了解、配置、安装插件的过程本身就是对Java的学习过程
2: Eclipse 免费、很多正规的软件开发公司，为了节省开发资源还是会使用Eclipse
3: Eclipse简洁、高校、不耗资源. MyEclipse版本越高服务、插件越多耗资源(当然可以关闭某些服务)
4: 采用Eclipse学习S2SH、MyBatis的时候不会自动生成配置文件.手动配置的方式可以让大家对框架的本身理解的更深刻
对Ecipse感兴趣的朋友可以去官网下载：http://www.eclipse.org/downloads/其实Eclipse为不同的开发人员提供的不同的IDE 其中 Eclipse IDE for Java EE Developers, 就是为J2EE程序员量身定做的 截图如下:
下载之后由于Eclipse是绿色版解压之后即可使用.此版本可以配置Tomcat容器 方法为: Window-->show view-->Server 打开Server面板选中要配置的Tomcat版本找到Tomcat目录即可. 配置完毕后就可以新建一个web项目.部署之后大家会看到运行项目没有任何问题.但是跑到Tomcat的webapps里面大家会发现并没有看到我们已经部署的项目这是为什么呢? 大家双击Tomcat服务会看到如下截图:
原来Eclipse把项目默认部署到了.metadata\.plugins\org.eclipse.wst.server.core\tmp0 目录而非Tomcat的安装目录. 所以我们应该修改此配置. 让它符合大家的使用习惯
选择 Use Tomcat installation 项目的Deploy path: 为Tomat中的webapps目录 即可. 通过如下设置 重新创建一个web项目后会发现项目部署到我们指定的tomcat中了。 这样完了吗? 还没有 免费的午餐不好用. 还有最后一个问题: 如果大家采用Eclipse开发S2SH应用的时候,由于包很多有很多时候我们都会有自己的用户库. 如下截图:
我个人喜欢把不同的框架Jar包放在不同的User库中.这样方便开发和教学,以后找源码也比较方便. 这种方便在MyEclipse运行的时候是没有问题的 但是在Eclilpse提示找不到系统类,原因是Eclipse部署的时候没有把用户包加载到lib目录中 设置如下:
工程==>properties==>Deployment Assembly==>Add==>Folder 经过了上面的设置我们的Eclipse就可以和MyEclipse一样开发WEB项目了. 希望对大家有所帮助. 此帖原创 转载请注明出处 谢谢！
十七、SVN管理知识点全面剖析
本文和大家学习一下SVN管理问题，SVN工作模型，分支的概念和版本库布局等内容，希望通过本文的学习，你对SVN管理有更加深刻的认识。
本节讲解一下SVN管理问题，在学习SVN的过程中，你可能会遇到SVN管理问题，只有掌握了SVN管理你才能够对SVN运用自如，欢迎大家一起来学习SVN管理。下面我们来看一下具体介绍。
一.SVN的工作模型：Subversion缺省使用复制-修改-合并模型
实际上是文件共享的问题，目前有两种策略：
A.锁定-修改-解锁模型有一点问题就是限制太多，经常会成为用户的障碍:
锁定可能导致管理问题。有时候Harry会锁住文件然后忘了此事，这就是说Sally一直等待解锁来编辑这些文件，她在这里僵住了。然后Harry去旅行了，现在Sally只好去找管理员放开锁，这种情况会导致不必要的耽搁和时间浪费。
锁定可能导致不必要的线性化开发。如果Harry编辑一个文件的开始，Sally想编辑同一个文件的结尾，这种修改不会冲突，设想修改可以正确的合并到一起，他们可以轻松的并行工作而没有太多的坏处，没有必要让他们轮流工作。
锁定可能导致错误的安全状态。假设Harry锁定和编辑一个文件A??Sally锁定并编辑文件B，如果A和B互相依赖，这种变化是必须同时作的，这样A和B不能正确的工作了，锁定机制对防止此类问题将无能为力—从而产生了一种处于安全状态的假相。很容易想象Harry和Sally都以为自己锁住了文件，而且从一个安全，孤立的情况开始工作，因而没有尽早发现他们不匹配的修改。
B.复制-修改-合并（CVS,SVN采用）
在这种模型里，每一个客户读取项目版本库建立一个私有工作副本—版本库中文件和目录的本地映射。用户并行工作，修改各自的工作副本，最终，各个私有的复制合并在一起，成为最终的版本，这种系统通常可以辅助合并操作，但是最终要靠人工去确定正误。
二。分支的概念
我们再来看一下SVN管理中分支的概念。版本控制系统的一个特性是能够把各种修改分离出来放在开发品的一个分割线上。这条线被称为分支。分支经常被用来试验新的特性，而不会对开发有编译错误的干扰。当新的特性足够稳定之后，开发品的分支就可以混合回主分支里(主干线).
版本控制系统的另一个特性是能够标记特殊的版本(例如某个发布版本)，所以你可以在任何时候重新建立一个特定的构件和环境。这个过程被称作标记。
分支中最重要的概念就是独立于主干进行开发，在合并前，不同分支提交的代码互相不可见，互不干扰。但是主干持有所有分支的版本记录，因此主干可以合并分支。比较适用不同团队独立开发各自模块。另外在分支合并的时候需要做回归测试
三。版本库的布局
SVN管理中版本库的布局情况，svn文档是有推荐的目录结构，适用大多数情况：）当然理解了分支的概念，心中有剑也无需受此限制。
1. Therearesomestandard,recommendedwaystoorganizearepository
2. .Mostpeoplecreateatrunkdirectorytoholdthe“mainline”ofdevelopment,abranchesdirectorytocontainbranchcopies
3. ,andatagsdirectorytocontaintagcopies.Ifarepositoryholdsonlyoneproject
4. ,thenoftenpeoplecreatethesetop-leveldirectories:
如果一个版本库包含多个项目，人们通常按分支来安排布局:
大致用法如下：
traceview项目有两个开发人员wya,htyoung，同时htyoung做为项目管理员.
1.项目开始时htyoung在trunk创建了最初的文件这个作为mainline,然后用
svncptrunktags/first_init
svncptags/first_initbranches/wya
svncptags/first_initbranches/htyoung
创建工作文件夹，我们的开发人员wya,htyoung只在他们的开发文件夹branches/wya，branches/htyoung内工作，也就是commit.
2.一段时间后由项目管理员(htyoung)，merge所有的修改到主线trunk上，同时htyoung和wya同主线同步.
3.再过一段时间我们发布0.1版本，为了有一个记录项目管理员(htyoung）用以下命令建了一个tags
svncptrunktags/Release0.1.0
4.这时又有一个开发人员JRD来了，项目管理员(htyoung）基于0.1给她建了一个工作分支svncptags/Release0.1.0branches/jrd
5.在我们发布完0.2时来了一个测试员TA,我们用以下命令为TA建一个工作文件夹
svncptrunktags/Release0.2.0
svncptags/Release0.2.0branches/ta。本节SVN管理问题讲解完毕。
Git是什么？
Git是目前世界上最先进的分布式版本控制系统（没有之一）。
Git有什么特点？简单来说就是：高端大气上档次！
那什么是版本控制系统？
如果你用Microsoft Word写过长篇大论，那你一定有这样的经历：
想删除一个段落，又怕将来想恢复找不回来怎么办？有办法，先把当前文件“另存为……”一个新的Word文件，再接着改，改到一定程度，再“另存为……”一个新文件，这样一直改下去，最后你的Word文档变成了这样：
过了一周，你想找回被删除的文字，但是已经记不清删除前保存在哪个文件里了，只好一个一个文件去找，真麻烦。
看着一堆乱七八糟的文件，想保留最新的一个，然后把其他的删掉，又怕哪天会用上，还不敢删，真郁闷。
更要命的是，有些部分需要你的财务同事帮助填写，于是你把文件Copy到U盘里给她（也可能通过Email发送一份给她），然后，你继续修改Word文件。一天后，同事再把Word文件传给你，此时，你必须想想，发给她之后到你收到她的文件期间，你作了哪些改动，得把你的改动和她的部分合并，真困难。
于是你想，如果有一个软件，不但能自动帮我记录每次文件的改动，还可以让同事协作编辑，这样就不用自己管理一堆类似的文件了，也不需要把文件传来传去。如果想查看某次改动，只需要在软件里瞄一眼就可以，岂不是很方便？
这个软件用起来就应该像这个样子，能记录每次文件的改动：
|
版本 |
用户 |
说明 |
日期 |
|
1 |
张三 |
删除了软件服务条款5 |
7/12 10:38 |
|
2 |
张三 |
增加了License人数限制 |
7/12 18:09 |
|
3 |
李四 |
财务部门调整了合同金额 |
7/13 9:51 |
|
4 |
张三 |
延长了免费升级周期 |
7/14 15:17 |
这样，你就结束了手动管理多个“版本”的史前时代，进入到版本控制的20世纪
cvs
cvs 是一个版本控制系统。使用它，可以记录下你的源文件的历史。
例如，修改软件时可能会不知不觉混进一些 bug，而且可能过了很久你才会察觉到它们的存在。有了 cvs，你可以很容易地恢复旧版本，并从中看出到底是哪个修改导致了这个 bug。有时这是很有用的。
CVS服务器端对每个文件维护着一个修订号,每次对文件的更新，都会使得文件的修订号加1。在客户端中也对每个文件维护着一个修订号,CVS通过这两个修订号的关系，来进行Update,Commit和发现冲突等操作操作
SVN与Git优缺点比较(属面试常问提)
1．SVN优缺点
优点：
1、 管理方便，逻辑明确，符合一般人思维习惯。
2、 易于管理，集中式服务器更能保证安全性。
3、 代码一致性非常高。
4、 适合开发人数不多的项目开发。
缺点：
1、 服务器压力太大，数据库容量暴增。
2、 如果不能连接到服务器上，基本上不可以工作，看上面第二步，如果服务器不能连接上，就不能提交，还原，对比等等。
3、 不适合开源开发（开发人数非常非常多，但是Google app engine就是用svn的）。但是一般集中式管理的有非常明确的权限管理机制（例如分支访问限制），可以实现分层管理，从而很好的解决开发人数众多的问题。
2．Git优缺点
优点：
1、适合分布式开发，强调个体。
2、公共服务器压力和数据量都不会太大。
3、速度快、灵活。
4、任意两个开发者之间可以很容易的解决冲突。
5、离线工作。
缺点：
1、学习周期相对而言比较长。
2、不符合常规思维。
3、代码保密性差，一旦开发者把整个库克隆下来就可以完全公开所有代码和版本信息。
十八、Linux常用的命令
显示目录和文件的命令
Ls：用于查看所有文件夹的命令。
Dir：用于显示指定文件夹和目录的命令 Tree： 以树状图列出目录内容
Du：显示目录或文件大小
修改目录，文件权限和属主及数组命令
Chmod：用于改变指定文件的权限命令。
Chown：用于改变文件拥有属性的命令。
Chgrp：用于改变文件群组的命令。
Chattr：用于设置文件具有不可删除和修改权限。
Lsattr：用于显示文件或目录的隐藏属性。
创建和删除目录的命令
Mkdir：用于创建目录
Rmdir：用于删除空的目录
Rm -f：用于删除不为空的目录
创建和删除，重命名，复制文件的命令
Touch：创建一个新的文件
Vi:创建一个新的文件
Rm：删除文件或目录
Mv：重命名或移动文件的命令
Cp：复制命令
显示文件内容的命令
Cat：用于显示指定文件的全部内容
More：用分页的形式显示指定文件的内容
Less：用分页的形式显示指定文件的内容，区别是more和less翻页使用的操作键不同。
Head：用于显示文件的前n行内容。
Tail：用于显示文件的后n行内容。
Tail -f：用于自动刷新的显示文件后n行数据内容。
查找命令
Find：查找指定的文件。
Whereis：查找指定的文件源和二进制文件和手册等
Which：用于查询命令或别名的位置。
Locate：快速查找系统数据库中指定的内容。
Grep：查找文件里符合条件的字符串。
关机和重启计算机的命令
Shutdown：-r 关机后立即重启
-k 并不真正的关机，而只是发出警告信息给所有用户
-h 关机后不重新启动
Poweroff：用于关机和关闭电源
Init：改变系统运行级别
0级用于关闭系统
1 级用于单一使用者模式
2级用来进行多用户使用模式（但不带网络功能）
3级用来进行多用户使用模式（带网络全功能）
4级用来进行用户自定义使用模式
5级表示进入x windows时的模式
6级用来重启系统
Reboot： 用于计算机重启
Halt：用于关闭计算机系统
压缩和打包命令
Tar：用于多个文件或目录进行打包，但不压缩，同时也用命令进行解包
Gzip：用于文件进行压缩和解压缩命令，文件扩展名为.gz结尾。
Gunzip：用于对gzip压缩文档进行解压缩。
Bzip2：用于对文件或目录进行压缩和解压缩
Bzcat：用于显示压缩文件的内容。
Compress/un compress： 压缩/解压缩.Z文件
Zcat：查看z或gz结尾的压缩文件内容。
Gzexe：压缩可执行的文件
Unarg：解压缩.arj文件
Zip/unzip:压缩解压缩.zip文件
用户操作命令
Su：切换用户命令
Sudo：一系统管理员的身份执行命令
Passwd：用于修改用户的密码
改变目录和查看当前目录命令
Cd：进入工作目录
Cd 。。：会退到上一级命令
Pwd：显示当前用户所在工作目录位置
文件连接命令
Ln：为源文件创建一个连接，并不将源文件复制一份，即占用的空间很小。
可以分为软件连接和硬链接。
软连接：也称为符号连接，即为文件或目录创建一个快捷方式。
硬链接：给一个文件取多于一个名字，放在不同目录中，方便用户使用。
Ln命令参数如下：
-f：在创建连接时，先将与目的对象同名的文件或目录删除。
-d：允许系统管理者硬链接自己的目录。
-i：在删除与目的对象同名文件或目录时先询问用户。
-n：在创建软连接时，将目的对象视为一般的文件。
-s：创建软连接，即符号连接。
-v：在连接之前显示文件或目录名。
-b：将在连接时会被覆盖或删除的文件进行备份。
帮助命令-----man
其他命令
Who：显示系统中有那些用户在使用。
-ami 显示当前用户
-u：显示使用者的动作/工作
-s：使用简短的格式来显示
-v：显示程序版本
Free：查看当前系统的内存使用情况
Uptime：显示系统运行了多长时间
Ps：显示瞬间进程的动态
Top: 动态地显示进程
Pstree：以树状方式显示系统中所有的进程
Date：显示或设定系统的日期与时间。
Last：显示每月登陆系统的用户信息
Kill： 杀死一些特定的进程
Logout：退出系统
Useradd/userdel:添加用户/删除用户
Clear：清屏
Passwd：设置用户密码
vi编辑器
首先用vi命令打开一个文件
末行模式命令：
:n,m w path/filename 保存指定范围文档（ n表开始行，m表结束行）
:q! 对文件做过修改后，强制退出
:q 没有对文件做过修改退出
Wq或x 保存退出
dd 删除光标所在行
： set number 显示行号
：n 跳转到n行
：s 替换字符串 :s/test/test2/g /g全局替换 /也可以用%代替
/ 查找字符串
网络通信常用的命令
Arp：网络地址显示及控制
ftp：文件传输
Lftp：文件传输
Mail：发送/接收电子邮件
Mesg：允许或拒绝其他用户向自己所用的终端发送信息
Mutt E-mail 管理程序
Ncftp ：文件传输
Netstat：显示网络连接.路由表和网络接口信息
Pine：收发电子邮件，浏览新闻组
Ping：用于查看网络是否连接通畅
Ssh：安全模式下远程登陆
Telnet：远程登录
Talk：与另一用户对话
Traceroute：显示到达某一主机所经由的路径及所使用的时间。
Wget：从网路上自动下载文件
Write：向其它用户终端写信息
Rlogin：远程登录
如今出去面试多少都会被问及个Linux的问题， 而且项目进uat后也都要发到linux下， 所以知道几个linux命令是必要的。
第一个，也是最有用的一个：
man 察看命令详解,只要觉得哪个命令不清楚，man它就可以了.
man ls
ln 创建链接文件
ln -s sourceName destName
ls 列出文件
-l: 逐行显示且列出详细属性
-a: 列出所有文件包括以.开头的隐藏文件
ls -lqt /bin
cat 读取文本内容
-n: 显示行号
-b: 显示行号且忽略空行
cat -n 1.txt
wc: 计数
-l: 行数
-w: 字数
-c: 字符数
wc -l file1 file2 ......可以统计多个文件
cp 拷贝文件 目录
-i: 交互模式，如果目标文件存在，则询问是否覆盖
-r: 拷贝目录
cp file1 file2 file3.... dir 表示将file1,file2...拷贝到dir
cp -r dir1 dir2 dir3... dirn 将dir1, dir2,dir3...拷贝到dirn
file 察看文件类型
file test.sh
mv 移动文件，更改文件名
-i: 交互模式，如果目标文件存在，则询问是否覆盖
-r: 移动目录，跟改目录名
rm 删除文件
-i: 交互模式，询问是否删除
rm -r dir1 dir2 dir3...可删除多个
mkdir 创建目录
-p: parent,父目录不存在，则创建父目录
mkdir -p test/test
rmdir 删除目录
等同与rm -r
rmdir dir1 dir2 dir3 ....
rm -r dir1 dir2 dir3 ....
chmod 更改权限
chmod -R 777 DIR改变目录下所有文件权限为777，必须是-R
权限 -rwxrwxrwx
421421421
最前面的-表示文件类型为普通文件
接下来三位表示所有者权限
接下来三位表示组权限
最后三位表示其它用户权限
如果某一权限没有被分配，用-表示。-rwxr--rwx表示组没有写和执行权限
文件加夜有可执行权限，但表示是否容许在该目录下寻找文件
chown 改变所有者
chgrp 改变组
command &
命令后面加&表示在后台运行
find . -name "*.sh"&
fg 把后台进程放到前台
fg %1 把后台第一个作业放到前台
bg
把前台进程放到后台
jobs
显示后台或挂起的进程
ps
显示所有进程
ps -f 显示完全信息，包括占用cpu时间，开始时间。。。
kill
-9 强制结束
more 显示文本内容，每次一屏，按空格继续
find / -name "*.sh" | more
tail 从指定的位置开始显示后面得内容
tail -f server.log 用于在server上边运行边察看日志
tail -10 dos2unix.sh 察看最后10行
head
与tail对应
sort 排序
-r 逆序
-d 字典顺序
ls | sort -r
tr 字符替换
-d 删除指定字符 ls | tr -d 'log'
ls | tr 'd' 'g'把d变成g
at time date job
定时调度
compress
-f 压缩文件
-v 显示压缩比例
compress -vf project.tar 将产生project.tar.Z且project.tar被删除
uncompress
-f 解压缩文件
-v 显示压缩比例
uncompress project.tar.Z 将产生project.tar且project.tar.Z被删除
tar
-c 创建新文档
-x 解包
-v 显示正在处理的文件名
-f 取代默认的文件名
tar -cvf project.tar project/* 把project目录下所有文件打包
tar -xvf project.tar
crontab
使用权限 : 所有使用者
使用方式 :
crontab [ -u user ] file
crontab [ -u user ] { -l | -r | -e }
crontab 指定使用者在固定时间执行程序，换句话说，即使用者的时程表。-u user 是指设定指定 user 的时程表，这个前提是你必须要有其权限(比如说是 root)才能够指定他人的时程表。如果不使用 -u user 的话，就是表示设定自己的时程表。
十九、JavaScript
介绍js的基本数据类型。
Undefined、Null、Boolean、Number、String、
ECMAScript 2015 新增:Symbol(创建后独一无二且不可变的数据类型 )
介绍js有哪些内置对象？
Object 是 JavaScript 中所有对象的父对象
数据封装类对象：Object、Array、Boolean、Number 和 String
其他对象：Function、Arguments、Math、Date、RegExp、Error
参考：http://www.ibm.com/developerwork ... injs-v1b/index.html
说几条写JavaScript的基本规范？
1.不要在同一行声明多个变量。
2.请使用 ===/!==来比较true/false或者数值
3.使用对象字面量替代new Array这种形式
4.不要使用全局函数。
5.Switch语句必须带有default分支
6.函数不应该有时候有返回值，有时候没有返回值。
7.For循环必须使用大括号
8.If语句必须使用大括号
9.for-in循环中的变量 应该使用var关键字明确限定作用域，从而避免作用域污染。
JavaScript原型，原型链 ? 有什么特点？
每个对象都会在其内部初始化一个属性，就是prototype(原型)，当我们访问一个对象的属性时，
如果这个对象内部不存在这个属性，那么他就会去prototype里找这个属性，这个prototype又会有自己的prototype，
于是就这样一直找下去，也就是我们平时所说的原型链的概念。
关系：instance.constructor.prototype = instance.__proto__
特点：
JavaScript对象是通过引用来传递的，我们创建的每个新对象实体中并没有一份属于自己的原型副本。当我们修改原型时，与之相关的对象也会继承这一改变。
当我们需要一个属性的时，Javascript引擎会先看当前对象中是否有这个属性， 如果没有的话，
就会查找他的Prototype对象是否有这个属性，如此递推下去，一直检索到 Object 内建对象。
function Func(){}
Func.prototype.name = "Sean";
Func.prototype.getInfo = function() {
return this.name;
}
var person = new Func();//现在可以参考var person = Object.create(oldObject);
console.log(person.getInfo());//它拥有了Func的属性和方法
//"Sean"
console.log(Func.prototype);
// Func { name="Sean", getInfo=function()}
JavaScript有几种类型的值？，你能画一下他们的内存图吗？
栈：原始数据类型（Undefined，Null，Boolean，Number、String）
堆：引用数据类型（对象、数组和函数）
两种类型的区别是：存储位置不同；
原始数据类型直接存储在栈(stack)中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储；
引用数据类型存储在堆(heap)中的对象,占据空间大、大小不固定。如果存储在栈中，将会影响程序运行的性能；引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体
如何将字符串转化为数字，例如’12.3b’?
* parseFloat('12.3b');
* 正则表达式，'12.3b'.match(/(\d)+(\.)?(\d)+/g)[0] * 1, 但是这个不太靠谱，提供一种思路而已。
如何将浮点数点左边的数每三位添加一个逗号，如12000000.11转化为『12,000,000.11』?
function commafy(num){
return num && num
.toString()
.replace(/(\d)(?=(\d{3})+\.)/g, function($1, $2){
return $2 + ',';
});
}
如何实现数组的随机排序？
· 方法一：
var arr = [1,2,3,4,5,6,7,8,9,10];
function randSort1(arr){
for(var i = 0,len = arr.length;i < len; i++ ){
var rand = parseInt(Math.random()*len);
var temp = arr[rand];
arr[rand] = arr;
arr = temp;
}
return arr;
}
console.log(randSort1(arr));
· 方法二：
var arr = [1,2,3,4,5,6,7,8,9,10];
function randSort2(arr){
var mixedArray = [];
while(arr.length > 0){
var randomIndex = parseInt(Math.random()*arr.length);
mixedArray.push(arr[randomIndex]);
arr.splice(randomIndex, 1);
}
return mixedArray;
}
console.log(randSort2(arr));
方法三：
var arr = [1,2,3,4,5,6,7,8,9,10];
arr.sort(function(){
return Math.random() - 0.5;
})
console.log(arr);
Javascript如何实现继承？
1、构造继承
2、原型继承
3、实例继承
4、拷贝继承
原型prototype机制或apply和call方法去实现较简单，建议使用构造函数与原型混合方式。
function Parent(){
this.name = 'wang';
}
function Child(){
this.age = 28;
}
Child.prototype = new Parent();//继承了Parent，通过原型
var demo = new Child();
alert(demo.age);
alert(demo.name);//得到被继承的属性
JavaScript继承的几种实现方式？
参考：构造函数的继承，非构造函数的继承；
javascript创建对象的几种方式？
javascript创建对象简单的说,无非就是使用内置对象或各种自定义对象，当然还可以用JSON；但写法有很多种，也能混合使用。
1、对象字面量的方式
person={firstname:"Mark",lastname:"Yun",age:25,eyecolor:"black"};
2、用function来模拟无参的构造函数
function Person(){}
var person=new Person();//定义一个function，如果使用new"实例化",该function可以看作是一个Class
person.name="Mark";
person.age="25";
person.work=function(){
alert(person.name+" hello...");
}
person.work();
3、用function来模拟参构造函数来实现（用this关键字定义构造的上下文属性）
function Pet(name,age,hobby){
this.name=name;//this作用域：当前对象
this.age=age;
this.hobby=hobby;
this.eat=function(){
alert("我叫"+this.name+",我喜欢"+this.hobby+",是个程序员");
}
}
var maidou =new Pet("麦兜",25,"coding");//实例化、创建对象
maidou.eat();//调用eat方法
4、用工厂方式来创建（内置对象）
var wcDog =new Object();
wcDog.name="旺财";
wcDog.age=3;
wcDog.work=function(){
alert("我是"+wcDog.name+",汪汪汪......");
}
wcDog.work();
5、用原型方式来创建
function Dog(){
}
Dog.prototype.name="旺财";
Dog.prototype.eat=function(){
alert(this.name+"是个吃货");
}
var wangcai =new Dog();
wangcai.eat();
6、用混合方式来创建
function Car(name,price){
this.name=name;
this.price=price;
}
Car.prototype.sell=function(){
alert("我是"+this.name+"，我现在卖"+this.price+"万元");
}
var camry =new Car("凯美瑞",27);
camry.sell();
Javascript作用链域?
全局函数无法查看局部函数的内部细节，但局部函数可以查看其上层的函数细节，直至全局细节。
当需要从局部函数查找某一属性或方法时，如果当前作用域没有找到，就会上溯到上层作用域查找，
直至全局函数，这种组织形式就是作用域链。
谈谈This对象的理解。
this总是指向函数的直接调用者（而非间接调用者）；
如果有new关键字，this指向new出来的那个对象；
在事件中，this指向触发这个事件的对象，特殊的是，IE中的attachEvent中的this总是指向全局对象Window；
eval是做什么的？
它的功能是把对应的字符串解析成JS代码并运行；
应该避免使用eval，不安全，非常耗性能（2次，一次解析成js语句，一次执行）。
由JSON字符串转换为JSON对象的时候可以用eval，var obj =eval('('+ str +')');
什么是window对象? 什么是document对象?
window对象是指浏览器打开的窗口。
document对象是Documentd对象（HTML 文档对象）的一个只读引用，window对象的一个属性。
null，undefined 的区别？
null 表示一个对象是“没有值”的值，也就是值为“空”；
undefined 表示一个变量声明了没有初始化(赋值)；
undefined不是一个有效的JSON，而null是；
undefined的类型(typeof)是undefined；
null的类型(typeof)是object；
Javascript将未赋值的变量默认值设为undefined；
Javascript从来不会将变量设为null。它是用来让程序员表明某个用var声明的变量时没有值的。
typeof undefined
//"undefined"
undefined :是一个表示"无"的原始值或者说表示"缺少值"，就是此处应该有一个值，但是还没有定义。当尝试读取时会返回 undefined；
例如变量被声明了，但没有赋值时，就等于undefined
typeof null
//"object"
null : 是一个对象(空对象, 没有任何属性和方法)；
例如作为函数的参数，表示该函数的参数不是对象；
注意：
在验证null时，一定要使用 === ，因为 == 无法分别 null 和 undefined
null == undefined // true
null === undefined // false
再来一个例子：
null
Q：有张三这个人么？
A：有！
Q：张三有房子么？
A：没有！
undefined
Q：有张三这个人么？
A：有！
Q: 张三有多少岁？
A: 不知道（没有被告诉）
写一个通用的事件侦听器函数。
// event(事件)工具集，来源：github.com/markyun
markyun.Event = {
// 页面加载完成后
readyEvent : function(fn) {
if (fn==null) {
fn=document;
}
var oldonload = window.onload;
if (typeof window.onload != 'function') {
window.onload = fn;
} else {
window.onload = function() {
oldonload();
fn();
};
}
},
// 视能力分别使用dom0||dom2||IE方式 来绑定事件
// 参数： 操作的元素,事件名称 ,事件处理程序
addEvent : function(element, type, handler) {
if (element.addEventListener) {
//事件类型、需要执行的函数、是否捕捉
element.addEventListener(type, handler, false);
} else if (element.attachEvent) {
element.attachEvent('on' + type, function() {
handler.call(element);
});
} else {
element['on' + type] = handler;
}
},
// 移除事件
removeEvent : function(element, type, handler) {
if (element.removeEventListener) {
element.removeEventListener(type, handler, false);
} else if (element.datachEvent) {
element.detachEvent('on' + type, handler);
} else {
element['on' + type] = null;
}
},
// 阻止事件 (主要是事件冒泡，因为IE不支持事件捕获)
stopPropagation : function(ev) {
if (ev.stopPropagation) {
ev.stopPropagation();
} else {
ev.cancelBubble = true;
}
},
// 取消事件的默认行为
preventDefault : function(event) {
if (event.preventDefault) {
event.preventDefault();
} else {
event.returnValue = false;
}
},
// 获取事件目标
getTarget : function(event) {
return event.target || event.srcElement;
},
// 获取event对象的引用，取到事件的所有信息，确保随时能使用event；
getEvent : function(e) {
var ev = e || window.event;
if (!ev) {
var c = this.getEvent.caller;
while (c) {
ev = c.arguments[0];
if (ev && Event == ev.constructor) {
break;
}
c = c.caller;
}
}
return ev;
}
};
[“1”, “2”, “3”].map(parseInt) 答案是多少？
parseInt() 函数能解析一个字符串，并返回一个整数，需要两个参数 (val, radix)，
其中 radix 表示要解析的数字的基数。【该值介于 2 ~ 36 之间，并且字符串中的数字不能大于radix才能正确返回数字结果值】;
但此处 map 传了 3 个 (element, index, array),我们重写parseInt函数测试一下是否符合上面的规则。
function parseInt(str, radix) {
return str+'-'+radix;
};
var a=["1", "2", "3"];
a.map(parseInt); // ["1-0", "2-1", "3-2"] 不能大于radix
因为二进制里面，没有数字3,导致出现超范围的radix赋值和不合法的进制解析，才会返回NaN
所以["1", "2", "3"].map(parseInt) 答案也就是：[1, NaN, NaN]
事件是？IE与火狐的事件机制有什么区别？ 如何阻止冒泡？
1. 我们在网页中的某个操作（有的操作对应多个事件）。例如：当我们点击一个按钮就会产生一个事件。是可以被 JavaScript 侦测到的行为。
2. 事件处理机制：IE是事件冒泡、Firefox同时支持两种事件模型，也就是：捕获型事件和冒泡型事件；
3. ev.stopPropagation();（旧ie的方法 ev.cancelBubble = true;）
什么是闭包（closure），为什么要用它？
闭包是指有权访问另一个函数作用域中变量的函数，创建闭包的最常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量,利用闭包可以突破作用链域，将函数内部的变量和方法传递到外部。
闭包的特性：
1.函数内再嵌套函数
2.内部函数可以引用外层的参数和变量
3.参数和变量不会被垃圾回收机制回收
//li节点的onclick事件都能正确的弹出当前被点击的li索引
<ul id="testUL">
<li> index = 0</li>
<li> index = 1</li>
<li> index = 2</li>
<li> index = 3</li>
</ul>
<script type="text/javascript">
var nodes = document.getElementsByTagName("li");
for(i = 0;i<nodes.length;i+= 1){
nodes.onclick = (function(i){
return function() {
console.log(i);
} //不用闭包的话，值每次都是4
})(i);
}
</script>
执行say667()后,say667()闭包内部变量会存在,而闭包内部函数的内部变量不会存在
使得Javascript的垃圾回收机制GC不会收回say667()所占用的资源
因为say667()的内部函数的执行需要依赖say667()中的变量
这是对闭包作用的非常直白的描述
function say667() {
// Local variable that ends up within closure
var num = 666;
var sayAlert = function() {
alert(num);
}
num++;
return sayAlert;
}
var sayAlert = say667();
sayAlert()//执行结果应该弹出的667
javascript 代码中的”use strict”;是什么意思 ? 使用它区别是什么？
use strict是一种ECMAscript 5 添加的（严格）运行模式,这种模式使得 Javascript 在更严格的条件下运行,
使JS编码更加规范化的模式,消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为。
默认支持的糟糕特性都会被禁用，比如不能用with，也不能在意外的情况下给全局变量赋值;
全局变量的显示声明,函数必须声明在顶层，不允许在非函数代码块内声明函数,arguments.callee也不允许使用；
消除代码运行的一些不安全之处，保证代码运行的安全,限制函数中的arguments修改，严格模式下的eval函数的行为和非严格模式的也不相同;
提高编译器效率，增加运行速度；
为未来新版本的Javascript标准化做铺垫。
如何判断一个对象是否属于某个类？
使用instanceof （待完善）
if(a instanceof Person){
alert('yes');
}
new操作符具体干了什么呢?
1、创建一个空对象，并且 this 变量引用该对象，同时还继承了该函数的原型。
2、属性和方法被加入到 this 引用的对象中。
3、新创建的对象由 this 所引用，并且最后隐式的返回 this 。
var obj = {};
obj.__proto__ = Base.prototype;
Base.call(obj);
用原生JavaScript的实现过什么功能吗？
Javascript中，有一个函数，执行时对象查找时，永远不会去查找原型，这个函数是？
hasOwnProperty
javaScript中hasOwnProperty函数方法是返回一个布尔值，指出一个对象是否具有指定名称的属性。此方法无法检查该对象的原型链中是否具有该属性；该属性必须是对象本身的一个成员。
使用方法：
object.hasOwnProperty(proName)
其中参数object是必选项。一个对象的实例。
proName是必选项。一个属性名称的字符串值。
如果 object 具有指定名称的属性，那么JavaScript中hasOwnProperty函数方法返回 true，反之则返回 false。
JSON 的了解？
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。
它是基于JavaScript的一个子集。数据格式简单, 易于读写, 占用带宽小
如：{"age":"12", "name":"back"}
JSON字符串转换为JSON对象:
var obj =eval('('+ str +')');
var obj = str.parseJSON();
var obj = JSON.parse(str);
JSON对象转换为JSON字符串：
var last=obj.toJSONString();
var last=JSON.stringify(obj);
[].forEach.call($$("*"),function(a){a.style.outline="1px solid #"+(~~(Math.random()*(1<<24))).toString(16)}) 能解释一下这段代码的意思吗？
js延迟加载的方式有哪些？
defer和async、动态创建DOM方式（用得最多）、按需异步载入js
Ajax 是什么? 如何创建一个Ajax？
ajax的全称：Asynchronous Javascript And XML。
异步传输+js+xml。
所谓异步，在这里简单地解释就是：向服务器发送请求的时候，我们不必等待结果，而是可以同时做其他的事情，等到有了结果它自己会根据设定进行后续操作，与此同时，页面是不会发生整页刷新的，提高了用户体验。
(1)创建XMLHttpRequest对象,也就是创建一个异步调用对象
(2)创建一个新的HTTP请求,并指定该HTTP请求的方法、URL及验证信息
(3)设置响应HTTP请求状态变化的函数
(4)发送HTTP请求
(5)获取异步调用返回的数据
(6)使用JavaScript和DOM实现局部刷新
Ajax 解决浏览器缓存问题？
1、在ajax发送请求前加上 anyAjaxObj.setRequestHeader("If-Modified-Since","0")。
2、在ajax发送请求前加上 anyAjaxObj.setRequestHeader("Cache-Control","no-cache")。
3、在URL后面加上一个随机数： "fresh=" + Math.random();。
4、在URL后面加上时间搓："nowtime=" + new Date().getTime();。
5、如果是使用jQuery，直接这样就可以了 $.ajaxSetup({cache:false})。这样页面的所有ajax都会执行这条语句就是不需要保存缓存记录。
同步和异步的区别?
同步的概念应该是来自于OS中关于同步的概念:不同进程为协同完成某项工作而在先后次序上调整(通过阻塞,唤醒等方式).同步强调的是顺序性.谁先谁后.异步则不存在这种顺序性.
同步：浏览器访问服务器请求，用户看得到页面刷新，重新发请求,等请求完，页面刷新，新内容出现，用户看到新内容,进行下一步操作。
异步：浏览器访问服务器请求，用户正常操作，浏览器后端进行请求。等请求完，页面不刷新，新内容也会出现，用户看到新内容。
如何解决跨域问题?
jsonp、 iframe、window.name、window.postMessage、服务器上设置代理页面
页面编码和被请求的资源编码如果不一致如何处理？
模块化开发怎么做？
立即执行函数,不暴露私有成员
var module1 = (function(){
var _count = 0;
var m1 = function(){
//...
};
var m2 = function(){
//...
};
return {
m1 : m1,
m2 : m2
};
})();
AMD（Modules/Asynchronous-Definition）、CMD（Common Module Definition）规范区别？
Asynchronous Module Definition，异步模块定义，所有的模块将被异步加载，模块加载不影响后面语句运行。所有依赖某些模块的语句均放置在回调函数中。
区别：
1. 对于依赖的模块，AMD 是提前执行，CMD 是延迟执行。不过 RequireJS 从 2.0 开始，也改成可以延迟执行（根据写法不同，处理方式不同）。CMD 推崇 as lazy as possible.
2. CMD 推崇依赖就近，AMD 推崇依赖前置。看代码：
// CMD
define(function(require, exports, module) {
var a = require('./a')
a.doSomething()
// 此处略去 100 行
var b = require('./b') // 依赖可以就近书写
b.doSomething()
// ...
})
// AMD 默认推荐
define(['./a', './b'], function(a, b) { // 依赖必须一开始就写好
a.doSomething()
// 此处略去 100 行
b.doSomething()
// ...
})
requireJS的核心原理是什么？（如何动态加载的？如何避免多次加载的？如何
缓存的？）
JS模块加载器的轮子怎么造，也就是如何实现一个模块加载器？
谈一谈你对ECMAScript6的了解？
ECMAScript6 怎么写class么，为什么会出现class这种东西?
异步加载JS的方式有哪些？
(1) defer，只支持IE
(2) async：
(3) 创建script，插入到DOM中，加载完毕后callBack
documen.write和 innerHTML的区别
document.write只能重绘整个页面
innerHTML可以重绘页面的一部分
DOM操作——怎样添加、移除、移动、复制、创建和查找节点?
（1）创建新节点
createDocumentFragment() //创建一个DOM片段
createElement() //创建一个具体的元素
createTextNode() //创建一个文本节点
（2）添加、移除、替换、插入
appendChild()
removeChild()
replaceChild()
insertBefore() //在已有的子节点前插入一个新的子节点
（3）查找
getElementsByTagName() //通过标签名称
getElementsByName() //通过元素的Name属性的值(IE容错能力较强，会得到一个数组，其中包括id等于name值的)
getElementById() //通过元素Id，唯一性
.call() 和 .apply() 的区别？
例子中用 add 来替换 sub，add.call(sub,3,1) == add(3,1) ，所以运行结果为：alert(4);
注意：js 中的函数其实是对象，函数名是对 Function 对象的引用。
function add(a,b)
{
alert(a+b);
}
function sub(a,b)
{
alert(a-b);
}
add.call(sub,3,1);
数组和对象有哪些原生方法，列举一下？
JS 怎么实现一个类。怎么实例化这个类
JavaScript中的作用域与变量声明提升？
如何编写高性能的Javascript？
那些操作会造成内存泄漏？
JQuery的源码看过吗？能不能简单概况一下它的实现原理？
jQuery.fn的init方法返回的this指的是什么对象？为什么要返回this？
jquery中如何将数组转化为json字符串，然后再转化回来？
jQuery 的属性拷贝(extend)的实现原理是什么，如何实现深拷贝？
jquery.extend 与 jquery.fn.extend的区别？
* jquery.extend 为jquery类添加类方法，可以理解为添加静态方法
* jquery.fn.extend:
源码中jquery.fn = jquery.prototype，所以对jquery.fn的扩展，就是为jquery类添加成员函数
使用：
jquery.extend扩展，需要通过jquery类来调用，而jquery.fn.extend扩展，所有jquery实例都可以直接调用。
jQuery 的队列是如何实现的？队列可以用在哪些地方？
谈一下Jquery中的bind(),live(),delegate(),on()的区别？
JQuery一个对象可以同时绑定多个事件，这是如何实现的？
是否知道自定义事件。jQuery里的fire函数是什么意思，什么时候用？
jQuery 是通过哪个方法和 Sizzle 选择器结合的？（jQuery.fn.find()进入Sizzle）
针对 jQuery性能的优化方法？
Jquery与jQuery UI 有啥区别？
*jQuery是一个js库，主要提供的功能是选择器，属性修改和事件绑定等等。
*jQuery UI则是在jQuery的基础上，利用jQuery的扩展性，设计的插件。
提供了一些常用的界面元素，诸如对话框、拖动行为、改变大小行为等等
JQuery的源码看过吗？能不能简单说一下它的实现原理？
jquery 中如何将数组转化为json字符串，然后再转化回来？
$.fn.stringifyArray = function(array) {
return JSON.stringify(array)
}
$.fn.parseArray = function(array) {
return JSON.parse(array)
}
然后调用：
$("").stringifyArray(array)
jQuery和Zepto的区别？各自的使用场景？
针对 jQuery 的优化方法？
*基于Class的选择性的性能相对于Id选择器开销很大，因为需遍历所有DOM元素。
*频繁操作的DOM，先缓存起来再操作。用Jquery的链式调用更好。
比如：var str=$("a").attr("href");
*for (var i = size; i < arr.length; i++) {}
for 循环每一次循环都查找了数组 (arr) 的.length 属性，在开始循环的时候设置一个变量来存储这个数字，可以让循环跑得更快：
for (var i = size, length = arr.length; i < length; i++) {}
Zepto的点透问题如何解决？
jQueryUI如何自定义组件?
需求：实现一个页面操作不会整页刷新的网站，并且能在浏览器前进、后退时正确响应。给出你的技术实现方案？
如何判断当前脚本运行在浏览器还是node环境中？（阿里）
this === window ? 'browser' : 'node';
通过判断Global对象是否为window，如果不为window，当前脚本没有运行在浏览器中
移动端最小触控区域是多大？
jQuery 的 slideUp动画 ，如果目标元素是被外部事件驱动, 当鼠标快速地连续触发外部元素事件, 动画会滞后的反复执行，该如何处理呢?
jquery stop(): 如：$("#div").stop().animate({width:"100px"},100);
把 Script 标签 放在页面的最底部的body封闭之前 和封闭之后有什么区别？浏览器会如何解析它们？
移动端的点击事件的有延迟，时间是多久，为什么会有？ 怎么解决这个延时？（click 有 300ms 延迟,为了实现safari的双击事件的设计，浏览器要知道你是不是要双击操作。）
知道各种JS框架(Angular, Backbone, Ember, React, Meteor, Knockout…)么? 能讲出他们各自的优点和缺点么?
Underscore 对哪些 JS 原生对象进行了扩展以及提供了哪些好用的函数方法？
解释JavaScript中的作用域与变量声明提升？
那些操作会造成内存泄漏？
内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。
垃圾回收器定期扫描对象，并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为 0（没有其他对象引用过该对象），或对该对象的惟一引用是循环的，那么该对象的内存即可回收。
setTimeout 的第一个参数使用字符串而非函数的话，会引发内存泄漏。
闭包、控制台日志、循环（在两个对象彼此引用且彼此保留时，就会产生一个循环）
JQuery一个对象可以同时绑定多个事件，这是如何实现的？
* 多个事件同一个函数：
$("div").on("click mouseover", function(){});
* 多个事件不同函数
$("div").on({
click: function(){},
mouseover: function(){}
});
Node.js的适用场景？
(如果会用node)知道route, middleware, cluster, nodemon, pm2, server-side rendering么?
解释一下 Backbone 的 MVC 实现方式？
什么是“前端路由”?什么时候适合使用“前端路由”? “前端路由”有哪些优点和缺点?
知道什么是webkit么? 知道怎么用浏览器的各种工具来调试和debug代码么?
Chrome,Safari浏览器内核。
如何测试前端代码么? 知道BDD, TDD, Unit Test么? 知道怎么测试你的前端工程么(mocha, sinon, jasmin, qUnit..)?
前端templating(Mustache, underscore, handlebars)是干嘛的, 怎么用?
简述一下 Handlebars 的基本用法？
简述一下 Handlerbars 的对模板的基本处理流程， 如何编译的？如何缓存的？
用js实现千位分隔符?(来源：前端农民工，提示：正则+replace)
function commafy(num) {
return num && num
.toString()
.replace(/(\d)(?=(\d{3})+\.)/g, function($0, $1) {
return $1 + ",";
});
}
console.log(commafy(1234567.90)); //1,234,567.90
检测浏览器版本版本有哪些方式？
功能检测、userAgent特征检测
比如：navigator.userAgent
//"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/41.0.2272.101 Safari/537.36"
What is a Polyfill?
polyfill 是“在旧版浏览器上复制标准 API 的 JavaScript 补充”,可以动态地加载 JavaScript 代码或库，在不支持这些标准 API 的浏览器中模拟它们。
例如，geolocation（地理位置）polyfill 可以在 navigator 对象上添加全局的 geolocation 对象，还能添加 getCurrentPosition 函数以及“坐标”回调对象，
所有这些都是 W3C 地理位置 API 定义的对象和函数。因为 polyfill 模拟标准 API，所以能够以一种面向所有浏览器未来的方式针对这些 API 进行开发，
一旦对这些 API 的支持变成绝对大多数，则可以方便地去掉 polyfill，无需做任何额外工作。
做的项目中，有没有用过或自己实现一些 polyfill 方案（兼容性处理方案）？
比如： html5shiv、Geolocation、Placeholder
我们给一个dom同时绑定两个点击事件，一个用捕获，一个用冒泡。会执行几次事件，会先执行冒泡还是捕获？
使用JS实现获取文件扩展名？
function getFileExtension(filename) {
return filename.slice((filename.lastIndexOf(".") - 1 >>> 0) + 2);
}
String.lastIndexOf() 方法返回指定值（本例中的'.'）在调用该方法的字符串中最后出现的位置，如果没找到则返回 -1。
对于'filename'和'.hiddenfile'，lastIndexOf的返回值分别为0和-1无符号右移操作符(»>) 将-1转换为4294967295，将-2转换为4294967294，这个方法可以保证边缘情况时文件名不变。
String.prototype.slice() 从上面计算的索引处提取文件的扩展名。如果索引比文件名的长度大，结果为""。
ECMAScript6 相关
Object.is() 与原来的比较操作符“ ===”、“ ==”的区别？
两等号判等，会在比较时进行类型转换；
三等号判等(判断严格)，比较时不进行隐式类型转换,（类型不同则会返回false）；
Object.is 在三等号判等的基础上特别处理了 NaN 、-0 和 +0 ，保证 -0 和 +0 不再相同，
但 Object.is(NaN, NaN) 会返回 true.
Object.is 应被认为有其特殊的用途，而不能用它认为它比其它的相等对比更宽松或严格。
二十、Ajax
1.ajax (asynchronous javascript and xml 异步地)
(1)ajax是什么?
是一种用来改善用户体验的技术，其本质是利用浏览器提供的一个特殊对象（XMLHttpRequest对象，也可以称之为ajax对象）向服务器发送异步请求，服务器返回部分数据，浏览器利用这些数据，对当前页面做部分更新。整个过程，页面无刷新，不打断用户的操作。
注：异步请求，指的是当这个对象向服务器发送请求时，浏览器不会销毁当前页面，用户仍然可以对当前页面做其它操作。
(2)如何获得ajax对象?
function getXhr(){
var xhr = null;
if(window.XMLHttpRequest){
//非ie
xhr = new XMLHttpRequest();
}else{
xhr = new ActiveXObject('MicroSoft.XMLHttp');
}
return xhr;
}
(3)ajax对象的几个重要属性
1)onreadystatechange:绑订事件处理函数（处理readystatechange事件）。
注：当ajax对象的readyState属性值发生了任何改变（比如从０变成了１，就会产生readystatechange事件）
2)readyState:有五个值(0,1,2,3,4),表示ajax对象与服务器通信的状态（进展）。４表示ajax对象已经获得了服务器返回的所有的数据。
3)responseText:获得服务器返回的文本。
4)responseXML:获得服务器返回的xml。
5)status:获得状态码。
(4)编程步骤
step1. 获得ajax对象
比如:var xhr = getXhr();
step2. 发送请求
情况一：发送get请求
xhr.open('get','check.do?uname=King',true);
xhr.onreadystatechange = f1;
xhr.send(null);
注:true:异步请求。false:同步请求（当ajax对象发送请求的时候，浏览器会锁定当前页面，用户不能够对当前页面做其它操作）。
情况二：发送post请求
xhr.open('post','check.do',true);
xhr.setRequestHeader('content-type','application/x-www-form-urlencoded');
xhr.onreadystatechange = f1;
xhr.send('uname=King');
注(了解):按照http协议要求，如果发送的是post请求，在请求数据包里面，应该包含有一个消息头("content-type")。因为ajax 对象默认情况下，不会添加该消息头，所以要调用setRequestHeader方法。
step3. 编写服务器端的程序通常只需要返回部分数据。
step4. 在事件处理函数里面，处理服务器返回数据。
function f1(){
if(xhr.readyState == 4 &&xhr.status == 200){
//必须保证已经收到了服务器返回的所有数据，并且没有出错。获得服务器返回的数据（文本）
var txt = xhr.responseText;
//更新页面
....
}
}
1、什么是AJAX，为什么要使用Ajax（请谈一下你对Ajax的认识）
什么是ajax：
AJAX是“Asynchronous JavaScript and XML”的缩写。他是指一种创建交互式网页应用的网页开发技术。
Ajax包含下列技术：
基于web标准（standards-basedpresentation）XHTML+CSS的表示；
使用 DOM（Document ObjectModel）进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
使用 JavaScript 将所有的东西绑定在一起。
2、为什么要用ajax：
Ajax应用程序的优势在于：
1. 通过异步模式，提升了用户体验
2. 优化了浏览器和服务器之间的传输，减少不必要的数据往返，减少了带宽占用
3. Ajax引擎在客户端运行，承担了一部分本来由服务器承担的工作，从而减少了大用户量下的服务器负载。
2、AJAX最大的特点是什么。
Ajax可以实现动态不刷新（局部刷新）
就是能在不更新整个页面的前提下维护数据。这使得Web应用程序更为迅捷地回应用户动作，并避免了在网络上发送那些没有改变过的信息。
3、请介绍一下XMLhttprequest对象。
Ajax的核心是JavaScript对象XmlHttpRequest。该对象在Internet Explorer 5中首次引入，它是一种支持异步请求的技术。简而言之，XmlHttpRequest使您可以使用JavaScript向服务器提出请求并处理响应，而不阻塞用户。通过XMLHttpRequest对象，Web开发人员可以在页面加载以后进行页面的局部更新。
4、AJAX技术体系的组成部分有哪些。
HTML，css，dom，xml，xmlHttpRequest，javascript
5、AJAX应用和传统Web应用有什么不同。
在传统的Javascript编程中，如果想得到服务器端数据库或文件上的信息，或者发送客户端信息到服务器，需要建立一个HTML form然后GET或者POST数据到服务器端。用户需要点击”Submit”按钮来发送或者接受数据信息，然后等待服务器响应请求，页面重新加载。
因为服务器每次都会返回一个新的页面， 所以传统的web应用有可能很慢而且用户交互不友好。
使用AJAX技术， 就可以使Javascript通过XMLHttpRequest对象直接与服务器进行交互。
通过HTTP Request， 一个web页面可以发送一个请求到web服务器并且接受web服务器返回的信息(不用重新加载页面)，展示给用户的还是通一个页面，用户感觉页面刷新，也看不到到Javascript后台进行的发送请求和接受响应。
6、AJAX请求总共有多少种CALLBACK。
Ajax请求总共有八种Callback
onSuccess
onFailure
onUninitialized
onLoading
onLoaded
onInteractive
onComplete
onException
7.Ajax和JavaScript的区别。
javascript是一种在浏览器端执行的脚本语言，Ajax是一种创建交互式网页应用的开发技术 ，它是利用了一系列相关的技术其中就包括javascript。
Javascript是由网景公司开发的一种脚本语言，它和sun公司的java语言是没有任何关系的，它们相似的名称只是一种行销策略。
在一般的web开发中，javascript是在浏览器端执行的，我们可以用javascript控制浏览器的行为和内容。
在 Ajax应用中信息是如何在浏览器和服务器之间传递的
通过XML数据或者字符串
8、在浏览器端如何得到服务器端响应的XML数据。
XMLHttpRequest对象的responseXMl属性
9、 XMLHttpRequest对象在IE和Firefox中创建方式有没有不同。
有，IE中通过new ActiveXObject()得到，Firefox中通过newXMLHttpRequest()得到
10、介绍一下XMLHttpRequest对象的常用方法和属性。
open(“method”,”URL”) 建立对服务器的调用，第一个参数是HTTP请求 方式可以为GET，POST或任何服务器所支持的您想调用的方式。
第二个参数是请求页面的URL。
send()方法，发送具体请求
abort()方法，停止当前请求
readyState属性 请求的状态 有5个可取值0=未初始化 ，1=正在加载
2=以加载，3=交互中，4=完成
responseText 属性 服务器的响应，表示为一个串
reponseXML 属性 服务器的响应，表示为XML
status 服务器的HTTP状态码，200对应ok 400对应not found
12、什么是XML
XML是扩展标记语言，能够用一系列简单的标记描述数据
13、XML的解析方式
常用的用dom解析和sax解析。dom解析是一次性读取xml文件并将其构造为DOM对象供程序使用，优点是操作方便，但是比较耗内存。Sax是按事件驱动的方式解析的，占用内存少，但是编程复杂
14、你采用的是什么框架（架包）
这题是必问的，一般也是最开始就会问到。
在java中比较流行的有 dojo, Prototype , JQuery, Dwr, extjs 等等
15、如果熟悉某种ajax框架，他可能会问到怎样在程序中使用这种框架
DWR框架介绍
DWR(DirectWeb Remoting)是一个WEB远程调用框架.利用这个框架可以让AJAX开发变得很简单.利用DWR可以在客户端利用JavaScript直接调用服务端的Java方法并返回值给JavaScript就好像直接本地客户端调用一样(DWR根据Java类来动态生成JavaScrip代码).
DWR的实现原理是通过反射，将java翻译成javascript，然后利用回调机制，从而实现了javascript调用Java代码
16、介绍一下Prototype的$()函数，$F()函数，$A()函数都是什么作用
$() 方法是在DOM中使用过于频繁的document.getElementById() 方法的一个便利的简写，就像这个DOM方法一样，这个方法返回参数传入的id的那个元素。
$F()函数是另一个大收欢迎的“快捷键”，它能用于返回任何表单输入控件的值，比如textbox,drop-down list。这个方法也能用元素id或元素本身做为参数。
$A()函数能把它接收到的单个的参数转换成一个Array对象。
17、介绍一下XMLHttpRequest对象
通过XMLHttpRequest对象，Web开发人员可以在页面加载以后进行页面的局部更新。
AJAX开始流行始于Google在2005年使用的”Google Suggest”。
“Google Suggest”就是使用XMLHttpRequest对象来创建动态的Web接口：
当用户开始输入google的搜索框，Javascript发送用户输入的字符到服务器，然后服务器返回一个建议列表。
XMLHttpRequest对象在IE5.0+, Safari 1.2, Mozilla1.0/Firefox, Opera 8+ 和NetScapt7 开始被支持。
18、AJAX的全称是什么？ 介绍一下AJAX？
AJAX的全称是Asynchronous JavaScript And XML.
AJAX是2005年由Google发起并流行起来的编程方法， AJAX不是一个新的编程语言，但是它是一个使用已有标准的新的编程技术。
使用AJAX可以创建更好，更快，更用户界面友好的Web应用。
AJAX技术基于javascript和HTTP Request.
19、Ajax主要包含了哪些技术？
Ajax（Asynchronous JavaScript + XML）的定义
基于web标准（standards-based presentation）XHTML+CSS的表示；
使用 DOM（Document Object Model）进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用XMLHttpRequest 进行异步数据查询、检索；
使用 JavaScript 将所有的东西绑定在一起。英文参见Ajax的提出者Jesse James Garrett的原文,原文题目(Ajax: A New Approach to Web Applications)。
类似于DHTML或LAMP，AJAX不是指一种单一的技术，而是有机地利用了一系列相关的技术。事实上，一些基于AJAX的“派生/合成”式（derivative/composite）的技术正在出现，如“AFLAX”。
AJAX的应用使用支持以上技术的web浏览器作为运行平台。这些浏览器目前包括：Mozilla、Firefox、Internet Explorer、Opera、Konqueror及Safari。但是Opera不支持XSL格式对象，也不支持XSLT。
20、AJAX都有哪些优点和缺点？
1、最大的一点是页面无刷新，用户的体验非常好。
2、使用异步方式与服务器通信，具有更加迅速的响应能力。
3、可以把以前一些服务器负担的工作转嫁到客户端，利用客户端闲置的能力来处理，减轻服务器和带宽的负担，节约空间和宽带租用成本。并且减轻服务器的负担，ajax的原则是“按需取数据”，可以最大程度的减少冗余请求，和响应对服务器造成的负担。
4、基于标准化的并被广泛支持的技术，不需要下载插件或者小程序。
ajax的缺点
1、ajax不支持浏览器back按钮。
2、安全问题 AJAX暴露了与服务器交互的细节。
3、对搜索引擎的支持比较弱。
4、破坏了程序的异常机制。
5、不容易调试。
二十一、Jquery
1 你在公司是怎么用jquery的？
答：在项目中是怎么用的是看看你有没有项目经验(根据自己的实际情况来回答) 你用过的选择器啊，复选框啊，表单啊，ajax啊，事件等
配置jQuery环境 下载jquery类库 在jsp页面引用jquery类库即可
<script type="text/JavaScript" src="jquery/jquery-1.7.2.min.js"/>
接下来通过在<script> $(function(){ }); </script>
2 你为什么要使用jquery？
答：因为jQuery是轻量级的框架，大小不到30kb,它有强大的选择器，出色的DOM操作的封装，有可靠的事件处理机制(jQuery在处理事件绑定的时候相当的可靠)，完善的ajax(它的ajax封装的非常的好，不需要考虑复杂浏览器的兼容性和XMLHttpRequest对象的创建和使用的问题。) 出色的浏览器的兼容性。 而且支持链式操作，隐式迭代。行为层和结构层的分离，还支持丰富的插件，jquery的文档也非常的丰富。
3 你觉得jquery有哪些好处？ 答案同上
4 你使用jquery遇到过哪些问题，你是怎么解决的？
答：这个答案是开发的，看你是否有相关的项目经验。
例前台拿不到值，JSON 可是出现的错误(多了一个空格等)这编译是不会报错的 jquery库与其他库冲突：
1>如果其他库在jquery库之前导入的话
1.我们可以通过jquery.noconflict()将变量的$的控制权过度给其他库
2.自定义快捷键,用一个变量接住jquery.noconflict()
3.通过函数传参
2>如果jquery库在其他库之前导入就直接使用jquery
今天在处理一个数据问题时，发现jQuery.ajax()方法返回的值一直有问题，清除缓存后数据无误，多次测试后发现返回的值都是之前的值，并且一直未执行url(后台为Java，设置断点一直未进入)。在网上查找下,发现是未设置type的原因。 如果没设置jQuery.ajax的type="Post"，那么ajax就会默认type="Get"，这就会导致之前数据被缓存起来。加上type="Post"，问题解决！
5 你知道jquery中的选择器吗，请讲一下有哪些选择器？
答 ：jQuery中的选择器大致分为:基本选择器，层次选择器，过滤选择器，表单选择器
6 jquery中的选择器 和 css中的选择器有区别吗？
答：jQuery选择器支持CSS里的选择器，jQuery选择器可用来添加样式和添加相应的行为CSS 中的选择器是只能添加相应的样式
7 你觉得jquery中的选择器有什么优势？
答：简单的写法 $('ID') 来代替 document.getElementById()函数
支持CSS1 到CSS3 选择器完善的处理机制(就算写错了id也不会报错)
8 你在使用选择器的时候有有没有什么觉得要注意的地方？
答: 1 选择器中含有".","#","[" 等特殊字符的时候需要进行转译
2 属性选择器的引号问题
3 选择器中含有空格的注意事项
9 jquery对象和dom对象是怎样转换的？
答 ：jquery转DOM对象:jQuery 对象是一个数组对象，可以通过[index]的丰富得到相应的DOM对象还可以通过get[index]去得到相应的DOM对象。DOM对象转jQuery对象:$(DOM对象)
10 你是如何使用jquery中的ajax的？
答: 如果是一些常规的ajax程序的话，使用load(),$.get(),$.post(),就可以搞定了，一般我会使用的是$.post() 方法。如果需要设定beforeSend(提交前回调函数),error(失败后处理),success(成功后处理)及complete(请求完成后处理)回调函数等，这个时候我会使用$.ajax()
11 你觉得jquery中的ajax好用吗，为什么？
答: 好用的。 因为jQuery提供了一些日常开发中夙瑶的快捷操作，例 load，ajax，get，post等等，所以使用jQuery开发ajax将变得极其简单，我们就可以集中精力在业务和用户的体验上，不需要去理会那些繁琐的XMLHttpRequest对象了。
12 jquery中$.get()提交和$.post()提交有区别吗？
答: 1 $.get() 方法使用GET方法来进行异步请求的。$.post() 方法使用POST方法来进行异步请求的。
2 get请求会将参数跟在URL后进行传递，而POST请求则是作为HTTP消息的实体内容发送给Web服务器的，这种传递是对用户不可见的。
3 get方式传输的数据大小不能超过2KB 而POST要大的多
4 GET 方式请求的数据会被浏览器缓存起来，因此有安全问题。
13 jquery中的load方法一般怎么用的？
答：load方法一般在 载入远程HTML 代码并插入到DOM中的时候用，通常用来从Web服务器上获取静态的数据文件。如果要传递参数的话，可以使用$.get() 或 $.post()。
14 在jquery中你是如何去操作样式的？
答: addClass() 来追加样式 ，removeClass() 来删除样式，toggle() 来切换样式
15 简单的讲叙一下jquery是怎么处理事件的，你用过哪些事件？
答: 首先去装载文档，在页面家在完毕后，浏览器会通过javascript 为DOM元素添加事件。
16 你使用过jquery中的动画吗，是怎样用的？
答:使用过。
hide() 和 show() 同时修改多个样式属性。像高度，宽度，不透明度。 fadeIn() 和fadeOut() fadeTo() 只改变不透明度
slideUp() 和 slideDown() slideToggle() 只改变高度
animate() 属于自定义动画的方法.
17 你使用过jquery中的插件吗？ 答:看个人的实力和经验来回答了。
18 你一般用什么去提交数据，为什么？
答:一般我会使用的是$.post() 方法。
如果需要设定beforeSend(提交前回调函数),error(失败后处理),success(成功后处理及complete(请求完成后处理)回调函数等，这个时候我会使用$.ajax()
19 在jquery中引入css有几种方式？
答:四种 行内式，内嵌式，导入式，链接式
20 你在jquery中使用过哪些插入节点的方法，它们的区别是什么？
答:append(),appendTo(),prepend(),prependTo(),after(),insertAfter()，before(),insertBefore() 大致可以分为 内部追加和外部追加append() 表式向每个元素内部追加内容。appendTo()表示 讲所有的元素追加到指定的元素中。例$(A)appendTo(B) 是将A追加到B中下面的方法解释类似。
21 你使用过包裹节点的方法吗，包裹节点有方法有什么好处？
答: wrapAll(),wrap(), wrapInner() 需要在文档中插入额外的结构化标记的时候可以使用这些包裹的方法应为它不会帛画原始文档的语义
22 jquery中如何来获取或和设置属性？
jQuery中可以用attr()方法来获取和设置元素属性removeAttr() 方法来删除元素属性
23 如何来设置和获取HTML 和文本的值？
答：html()方法 类似于innerHTML属性 可以用来读取或者设置某个元素中的HTML内容
注意：html() 可以用于xhtml文档 不能用于xml文档text() 类似于innerText属性 可以用来读取或设置某个元素中文本内容。val() 可以用来设置和获取元素的值
24 你jquery中有哪些方法可以遍历节点？
答 ：children() 取得匹配元素的子元素集合,只考虑子元素不考虑后代元素 next() 取得匹配元素后面紧邻的同辈元素
prev() 取得匹配元素前面紧邻的同辈元素
siblings() 取得匹配元素前后的所有同辈元素
closest() 取得最近的匹配元素
find() 取得匹配元素中的元素集合 包括子代和后代
25 子元素选择器 和后代选择器元素有什么区别？
答:子代元素是找子节点下的所有元素,后代元素是找子节点或子节点的子节点中的元素26 在jquery中可以替换节点吗？
答：可以 在jQuery中有两者替换节点的方式 replaceWith() 和 replaceAll()例如在<p title="hao are you">hao are you</p>替换成<strong>I am fine<strong>$('p').replaceWith('<strong>I am fine</strong>'); replaceAll 与replaceWith的用法前后调换一下即可。
27 你觉得beforeSend方法有什么用？
答：发送请求前可以修改XMLHttpRequest对象的函数，在beforeSend中如果返回false 可以取消本次的Ajax请求。XMLHttpRequest对象是唯一的参数所以在这个方法里可以做验证
28 siblings() 方法 和 $('prev~div')选择器是一样的嘛？
答: $('prev~div') 只能选择'#prev'元素后面的同辈<div>元素而siblings()方法与前后的文职无关，只要是同辈节点就都能匹配。
29 你在ajax中使用过JSON吗，你是如何用的？
答:使用过，在$.getJSON() 方法的时候就是。
因为 $.getJSON() 就是用于加载JSON文件的
30 有哪些查询节点的选择器？
答：我在公司使用过 :first 查询第一个，:last 查询最后一个，:odd查询奇数但是索引从0开始:even 查询偶数，:eq(index)查询相等的 ,:gt(index)查询大于index的 ,:lt查询小于index:header 选取所有的标题等
31 nextAll() 能 替代$('prev~siblindgs')选择器吗？
答:能。 使用nextAll() 和使用$('prev~siblindgs') 是一样的
32 jQuery中有几种方法可以来设置和获取样式
答 ：addClass() 方法，attr() 方法
33 $(document).ready()方法和window.onload有什么区别？
答: 两个方法有相似的功能，但是在实行时机方面是有区别的。 1window.onload方法是在网页中所有的元素(包括元素的所有关联文件)完全加载到浏览器后才执行的。
2 $(document).ready() 方法可以在DOM载入就绪时就对其进行操纵，并调用执行绑定的函数。
34 jQuery是如何处理缓存的？
答 ：要处理缓存就是禁用缓存.
1 通过$.post() 方法来获取数据，那么默认就是禁用缓存的。
2 通过$.get()方法 来获取数据，可以通过设置时间戳来避免缓存。可以在URL后面加上+(+new Date)例 $.get('ajax.xml?'+(+new Date),function () { //内容 }); 3 通过$.ajax 方法来获取数据，只要设置cache:false即可。
35 $.getScript()方法 和 $.getJson() 方法有什么区别？
答: 1 $.getScript() 方法可以直接加载.js文件，并且不需要对javascript文件进行处理，javascript文件会自动执行。
2 $.getJson() 是用于加载JSON 文件的 ，用法和$.getScript()
36 你读过有关于jQuery的书吗？
《jquery基础教程》 《jquery实战》《锋利的jquery》 《巧用jquery》 《jQuery用户界面库学习指南》等
37 $("#msg").text(); 和 $("#msg").text("<b>new content</b>");有什么区别？
答：1 $("#msg").text() 是 返回id为msg的元素节点的文本内容
2 $("#msg").text("<b>new content</b>"); 是 将“<b>new content</b>” 作为普通文本串写入id为msg的元素节点内容中, 页面显示粗体的<b>new content</b>
38 radio单选组的第二个元素为当前选中值，该怎么去取？
答 : $('input[name=items]').get(1).checked = true;
39 选择器中 id，class有什么区别？
答：在网页中 每个id名称只能用一次，class可以允许重复使用
40 你使用过哪些数据格式，它们各有什么特点？
答: HTML格式 ,JSON格式,javascript格式,XML格式
1 HTML片段提供外部数据一般来说是最简单的。
2 如果数据需要重用，而且其他应用程序也可能一次受到影响，那么在性能和文件大小方面具有优势的JSON通常是不错的选择。
3 而当远程应用程序未知时，XML则能够为良好的互操作性提供最可靠的保证。
41 jQuery 能做什么？
答：1 获取页面的元素
2 修改页面的外观
3 改变页面大的内容
4 响应用户的页面操作
5 为页面添加动态效果
6 无需刷新页面，即可以从服务器获取信息
7 简化常见的javascript任务
42 在ajax中data主要有几种方式？
答 ： 三种，html拼接的，json数组，form表单经serialize()序列化的。
43 ：jQuery中的hover()和toggle()有什么区别？
答 hover()和toggle()都是jQuery中两个合成事件。
hover()方法用于模拟光标悬停事件。 toggle()方法是连续点击事件。
44 你知道jQuery中的事件冒泡吗，它是怎么执行的，何如来停止冒泡事件？
答 : 知道,事件冒泡是从里面的往外面开始触发。在jQuery中提供了stopPropagation()方法可以停止冒泡。
45 例如 单击超链接后会自动跳转，单击"提交"按钮后表单会提交等，有时候我想阻止这些默认的行为，该怎么办？
答: 可以用 event.preventDefault()或在事件处理函数中返回false，即 return false;
46.jquery表单提交前有几种校验方法？分别为？？
a) formData:返回一个数组，可以通过循环调用来校验
b) jaForm：返回一个jQuery对象，所有需要先转换成dom对象
c) fieldValue：返回一个数组beforeSend()
47.在jquery中你有没有编写过插件，插件有什么好处？你编写过那些插件？它应该注意那些？
a) 答: 插件的好处：对已有的一系列方法或函数的封装，以便在其他地方重新利用，方便后期维护和提高开发效率插件的分类：封装对象方法插件 、封装全局函数插件、选择器插件
b) 注意的地方：
i. 1.插件的文件名推荐命名为jquery.[插件名].js，以免和其他的javaScript库插件混淆
ii. 2.所有的对象方法都应当附加到jQuery.fn对象上，而所有的全局函数都应当附加到jQuery对象本身上
iii. 3.插件应该返回一个jQuery对象，以保证插件的可链式操作
iv. 4.避免在插件内部使用$作为jQuery对象的别名,而应使用完整的jQuery来表示，这样可以避免冲突或使用闭包来避免
v. 5.所有的方法或函数插件，都应当一分好结尾，否则压缩的时候可能出现问题。在插件头部加上分号，这样可以避免他人的不规范代码给插件带来影响
vi. 6.在插件中通过$.extent({})封装全局函数,选择器插件，扩展已有的object对象通过$.fn.extend({})封装对象方法插件
二十二、HTML&CSS
1、新的 HTML5 文档类型和字符集是？
HTML5 文档类型很简单：
|
1 |
<!doctype html> |
HTML5 使用 UTF-8 编码示例：
|
1 |
<meta charset=”UTF-8″> |
2、HTML5 中如何嵌入音频？
HTML5 支持 MP3、Wav 和 Ogg 格式的音频，下面是在网页中嵌入音频的简单示例：
|
1 2 3 4 |
<audio controls> <source src=”jamshed.mp3″ type=”audio/mpeg”> Your browser does’nt support audio embedding feature. </audio> |
3、HTML5 中如何嵌入视频？
和音频类似，HTML5支持 MP4、WebM 和 Ogg 格式的视频，下面是简单示例：
|
1 2 3 4 |
<video width=”450″ height=”340″ controls> <source src=”jamshed.mp4″ type=”video/mp4″> Your browser does’nt support video embedding feature. </video> |
4、除了 audio 和 video，HTML5 还有哪些媒体标签？
HTML5对于多媒体提供了强有力的支持，除了 audio 和 video 标签外，还支持以下标签：
<embed> 标签定义嵌入的内容，比如插件。
|
1 |
<embed type=”video/quicktime” src=”Fishing.mov”> |
<source> 对于定义多个数据源很有用。
|
1 2 3 4 |
<video width=”450″ height=”340″ controls> <source src=”jamshed.mp4″ type=”video/mp4″> <source src=”jamshed.ogg” type=”video/ogg”> </video> |
<track> 标签为诸如 video 元素之类的媒介规定外部文本轨道。 用于规定字幕文件或其他包含文本的文件，当媒介播放时，这些文件是可见的。
|
1 2 3 4 5 6 |
<video width=”450″ height=”340″ controls> <source src=”jamshed.mp4″ type=”video/mp4″> <source src=”jamshed.ogg” type=”video/ogg”> <track kind=”subtitles” label=”English” src=”jamshed_en.vtt” srclang=”en” default></track> <track kind=”subtitles” label=”Arabic” src=”jamshed_ar.vtt” srclang=”ar”></track></video> |
5、HTML5 Canvas 元素有什么用？
Canvas 元素用于在网页上绘制图形，该元素标签强大之处在于可以直接在HTML上进行图形操作，
|
1 2 |
<canvas id=”canvas1″ width=”300″ height=”100″> </canvas> |
·不可思议的 HTML5 Canvas 应用试验
·18个基于 HTML5 Canvas 的图表库
·20个惊艳的 HTML5 Canvas 应用试验
·16款 HTML5 Canvas 开发的网页游戏
·推荐14款强大的HTML5素描及绘图工具
6、HTML5 存储类型有什么区别？
HTML5 能够本地存储数据，在之前都是使用 cookies 使用的。HTML5提供了下面两种本地存储方案：
·localStorage用于持久化的本地存储，数据永远不会过期，关闭浏览器也不会丢失。
·sessionStorage同一个会话中的页面才能访问并且当会话结束后数据也随之销毁。因此sessionStorage不是一种持久化的本地存储，仅仅是会话级别的存储
7、HTML5 有哪些新增的表单元素？
HTML5 新增了很多表单元素让开发者构建更优秀的 Web 应用程序。
·datalist
·datetime
·output
·keygen
·date
·month
·week
·time
·color
·number
·range
·url
8、HTML5 废弃了哪些 HTML4 标签？
HTML5 废弃了一些过时的，不合理的HTML标签：
·frame
·frameset
·noframe
·applet
·big
·center
·basefront
9、HTML5 标准提供了哪些新的 API？
HTML5 提供的应用程序 API 主要有：
·Media API
·Text Track API
·Application Cache API
·User Interaction
·Data Transfer API
·Command API
·Constraint Validation API
·History API
10、HTML5 应用程序缓存和浏览器缓存有什么区别？
应用程序缓存是HTML5的重要特性之一，提供了离线使用的功能，让应用程序可以获取本地的网站内容，例如 HTML、CSS、图片以及 JavaScript。这个特性可以提高网站性能，它的实现借助于 manifest 文件，如下：
|
1 2 3 4 |
<!doctype html> <html manifest=”example.appcache”> ….. </html> |
与传统浏览器缓存相比，它不强制用户访问的网站内容被缓存。
CSS：
介绍一下标准的CSS的盒子模型？低版本IE的盒子模型有什么不同的？
（1）有两种，IE 盒子模型、W3C 盒子模型；
（2）盒模型：内容(content)、填充(padding)、边界(margin)、边框(border)；
（3）区别：IE的content部分把 border 和 padding计算了进去;
CSS选择符有哪些？哪些属性可以继承？
* 1.id选择器（ # myid）
2.类选择器（.myclassname）
3.标签选择器（div, h1, p）
4.相邻选择器（h1 + p）
5.子选择器（ul > li）
6.后代选择器（li a）
7.通配符选择器（ * ）
8.属性选择器（a[rel = "external"]）
9.伪类选择器（a:hover, li:nth-child）
*可继承的样式： font-size font-family color, UL LI DL DD DT;
*不可继承的样式：border padding margin width height;
CSS优先级算法如何计算？
* 优先级就近原则，同权重情况下样式定义最近者为准;
* 载入样式以最后载入的定位为准;
优先级为:
!important > id > class > tag
important 比 内联优先级高
CSS3新增伪类有那些？
举例：
p:first-of-type 选择属于其父元素的首个 <p> 元素的每个 <p> 元素。
p:last-of-type 选择属于其父元素的最后 <p> 元素的每个 <p> 元素。
p:only-of-type 选择属于其父元素唯一的 <p> 元素的每个 <p> 元素。
p:only-child 选择属于其父元素的唯一子元素的每个 <p> 元素。
p:nth-child(2) 选择属于其父元素的第二个子元素的每个 <p> 元素。
:after 在元素之前添加内容,也可以用来做清除浮动。
:before 在元素之后添加内容
:enabled
:disabled 控制表单控件的禁用状态。
:checked 单选框或复选框被选中。
如何居中div？如何居中一个浮动元素？如何让绝对定位的div居中？
给div设置一个宽度，然后添加margin:0 auto属性
div{
width:200px;
margin:0 auto;
}
居中一个浮动元素
确定容器的宽高 宽500 高 300 的层
设置层的外边距
.div {
width:500px ; height:300px;//高度可以不设
margin: -150px 0 0 -250px;
position:relative; //相对定位
background-color:pink; //方便看效果
left:50%;
top:50%;
}
让绝对定位的div居中
position: absolute;
width: 1200px;
background: none;
margin: 0 auto;
top: 0;
left: 0;
bottom: 0;
right: 0;
display有哪些值？说明他们的作用。
block 象块类型元素一样显示。
none 缺省值。象行内元素类型一样显示。
inline-block 象行内元素一样显示，但其内容象块类型元素一样显示。
list-item 象块类型元素一样显示，并添加样式列表标记。
table 此元素会作为块级表格来显示
inherit 规定应该从父元素继承 display 属性的值
position的值relative和absolute定位原点是？
absolute
生成绝对定位的元素，相对于值不为 static的第一个父元素进行定位。
fixed （老IE不支持）
生成绝对定位的元素，相对于浏览器窗口进行定位。
relative
生成相对定位的元素，相对于其正常位置进行定位。
static
默认值。没有定位，元素出现在正常的流中（忽略 top, bottom, left, right z-index 声明）。
inherit
规定从父元素继承 position 属性的值。
CSS3有哪些新特性？
新增各种CSS选择器 （: not(.input)：所有 class 不是“input”的节点）
圆角 （border-radius:8px）
多列布局 （multi-column layout）
阴影和反射 （Shadow\Reflect）
文字特效 （text-shadow、）
文字渲染 （Text-decoration）
线性渐变 （gradient）
旋转 （transform）
增加了旋转,缩放,定位,倾斜,动画，多背景
transform:\scale(0.85,0.90)\ translate(0px,-30px)\ skew(-9deg,0deg)\Animation:
请解释一下CSS3的Flexbox（弹性盒布局模型）,以及适用场景？
：）
用纯CSS创建一个三角形的原理是什么？
把上、左、右三条边隐藏掉（颜色设为 transparent）
#demo {
width: 0;
height: 0;
border-width: 20px;
border-style: solid;
border-color: transparent transparent red transparent;
}
一个满屏 品 字布局 如何设计?
简单的方式：
上面的div宽100%，
下面的两个div分别宽50%，
然后用float或者inline使其不换行即可
经常遇到的浏览器的兼容性有哪些？原因，解决方法是什么，常用hack的技巧 ？
* png24位的图片在iE6浏览器上出现背景，解决方案是做成PNG8.
* 浏览器默认的margin和padding不同。解决方案是加一个全局的*{margin:0;padding:0;}来统一。
* IE6双边距bug:块属性标签float后，又有横行的margin情况下，在ie6显示margin比设置的大。
浮动ie产生的双倍距离 #box{ float:left; width:10px; margin:0 0 0 100px;}
这种情况之下IE会产生20px的距离，解决方案是在float的标签样式控制中加入 ——_display:inline;将其转化为行内属性。(_这个符号只有ie6会识别)
渐进识别的方式，从总体中逐渐排除局部。
首先，巧妙的使用“\9”这一标记，将IE游览器从所有情况中分离出来。
接着，再次使用“+”将IE8和IE7、IE6分离开来，这样IE8已经独立识别。
css
.bb{
background-color:#f1ee18;/*所有识别*/
.background-color:#00deff\9; /*IE6、7、8识别*/
+background-color:#a200ff;/*IE6、7识别*/
_background-color:#1e0bd1;/*IE6识别*/
}
* IE下,可以使用获取常规属性的方法来获取自定义属性,
也可以使用getAttribute()获取自定义属性;
Firefox下,只能使用getAttribute()获取自定义属性。
解决方法:统一通过getAttribute()获取自定义属性。
* IE下,even对象有x,y属性,但是没有pageX,pageY属性;
Firefox下,event对象有pageX,pageY属性,但是没有x,y属性。
* 解决方法：（条件注释）缺点是在IE浏览器下可能会增加额外的HTTP请求数。
* Chrome 中文界面下默认会将小于 12px 的文本强制按照 12px 显示,
可通过加入 CSS 属性 -webkit-text-size-adjust: none; 解决。
超链接访问过后hover样式就不出现了 被点击访问过的超链接样式不在具有hover和active了解决方法是改变CSS属性的排列顺序:
L-V-H-A : a:link {} a:visited {} a:hover {} a:active {}
li与li之间有看不见的空白间隔是什么原因引起的？有什么解决办法？
行框的排列会受到中间空白（回车\空格）等的影响，因为空格也属于字符,这些空白也会被应用样式，占据空间，所以会有间隔，把字符大小设为0，就没有空格了。
为什么要初始化CSS样式。
- 因为浏览器的兼容问题，不同浏览器对有些标签的默认值是不同的，如果没对CSS初始化往往会出现浏览器之间的页面显示差异。
- 当然，初始化样式会对SEO有一定的影响，但鱼和熊掌不可兼得，但力求影响最小的情况下初始化。
最简单的初始化方法： * {padding: 0; margin: 0;} （强烈不建议）
淘宝的样式初始化代码：
body, h1, h2, h3, h4, h5, h6, hr, p, blockquote, dl, dt, dd, ul, ol, li, pre, form, section, legend, button, input, textarea, th, td { margin:0; padding:0; }
body, button, input, select, textarea { font:12px/1.5tahoma, arial, \5b8b\4f53; }
h1, h2, h3, h4, h5, h6{ font-size:100%; }
address, cite, dfn, em, var { font-style:normal; }
code, kbd, pre, samp { font-family:couriernew, courier, monospace; }
small{ font-size:12px; }
ul, ol { list-style:none; }
a { text-decoration:none; }
a:hover { text-decoration:underline; }
sup { vertical-align:text-top; }
sub{ vertical-align:text-bottom; }
legend { color:#000; }
section, img { border:0; }
button, input, select, textarea { font-size:100%; }
table { border-collapse:collapse; border-spacing:0; }
absolute的containing block(容器块)计算方式跟正常流有什么不同？
无论属于哪种，都要先找到其祖先元素中最近的 position 值不为 static 的元素，然后再判断：
1、若此元素为 inline 元素，则 containing block 为能够包含这个元素生成的第一个和最后一个 inline box 的 padding box (除 margin, border 外的区域) 的最小矩形；
2、否则,则由这个祖先元素的 padding box 构成。
如果都找不到，则为 initial containing block。
补充：
1. static(默认的)/relative：简单说就是它的父元素的内容框（即去掉padding的部分）
2. absolute: 向上找最近的定位为absolute/relative的元素
3. fixed: 它的containing block一律为根元素(html/body)，根元素也是initial containing block
CSS里的visibility属性有个collapse属性值是干嘛用的？在不同浏览器下以后什么区别？
position跟display、margin collapse、overflow、float这些特性相互叠加后会怎么样？
对BFC规范(块级格式化上下文：block formatting context)的理解？
（W3C CSS 2.1 规范中的一个概念,它是一个独立容器，决定了元素如何对其内容进行定位,以及与其他元素的关系和相互作用。）
一个页面是由很多个 Box 组成的,元素的类型和 display 属性,决定了这个 Box 的类型。
不同类型的 Box,会参与不同的 Formatting Context（决定如何渲染文档的容器）,因此Box内的元素会以不同的方式渲染,也就是说BFC内部的元素和外部的元素不会互相影响。
css定义的权重
以下是权重的规则：标签的权重为1，class的权重为10，id的权重为100，以下例子是演示各种定义的权重值：
/*权重为1*/
div{
}
/*权重为10*/
.class1{
}
/*权重为100*/
#id1{
}
/*权重为100+1=101*/
#id1 div{
}
/*权重为10+1=11*/
.class1 div{
}
/*权重为10+10+1=21*/
.class1 .class2 div{
}
如果权重相同，则最后定义的样式会起作用，但是应该避免这种情况出现
请解释一下为什么会出现浮动和什么时候需要清除浮动？清除浮动的方式
移动端的布局用过媒体查询吗？
使用 CSS 预处理器吗？喜欢那个？
SASS (SASS、LESS没有本质区别，只因为团队前端都是用的SASS)
CSS优化、提高性能的方法有哪些？
浏览器是怎样解析CSS选择器的？
在网页中的应该使用奇数还是偶数的字体？为什么呢？
margin和padding分别适合什么场景使用？
抽离样式模块怎么写，说出思路，有无实践经验？[阿里航旅的面试题]
元素竖向的百分比设定是相对于容器的高度吗？
全屏滚动的原理是什么？用到了CSS的那些属性？
什么是响应式设计？响应式设计的基本原理是什么？如何兼容低版本的IE？
视差滚动效果，如何给每页做不同的动画？（回到顶部，向下滑动要再次出现，和只出现一次分别怎么做？）
::before 和 :after中双冒号和单冒号 有什么区别？解释一下这2个伪元素的作用。
如何修改chrome记住密码后自动填充表单的黄色背景 ？
你对line-height是如何理解的？
设置元素浮动后，该元素的display值是多少？（自动变成display:block）
怎么让Chrome支持小于12px 的文字？
让页面里的字体变清晰，变细用CSS怎么做？（-webkit-font-smoothing: antialiased;）
font-style属性可以让它赋值为“oblique” oblique是什么意思？
position:fixed;在android下无效怎么处理？
如果需要手动写动画，你认为最小时间间隔是多久，为什么？（阿里）
多数显示器默认频率是60Hz，即1秒刷新60次，所以理论上最小间隔为1/60＊1000ms ＝ 16.7ms
display:inline-block 什么时候会显示间隙？(携程)
移除空格、使用margin负值、使用font-size:0、letter-spacing、word-spacing
overflow: scroll时不能平滑滚动的问题怎么处理？
有一个高度自适应的div，里面有两个div，一个高度100px，希望另一个填满剩下的高度。
png、jpg、gif 这些图片格式解释一下，分别什么时候用。有没有了解过webp？
什么是Cookie 隔离？（或者说：请求资源的时候不要让它带cookie怎么做）
如果静态文件都放在主域名下，那静态文件请求的时候都带有的cookie的数据提交给server的，非常浪费流量，所以不如隔离开。
因为cookie有域的限制，因此不能跨域提交请求，故使用非主要域名的时候，请求头中就不会带有cookie数据，这样可以降低请求头的大小，降低请求时间，从而达到降低整体请求延时的目的。
同时这种方式不会将cookie传入Web Server，也减少了Web Server对cookie的处理分析环节，提高了webserver的http请求的解析速度。
style标签写在body后与body前有什么区别？
什么是CSS 预处理器 / 后处理器？
- 预处理器例如：LESS、Sass、Stylus，用来预编译Sass或less，增强了css代码的复用性，还有层级、mixin、变量、循环、函数等，具有很方便的UI组件模块化开发能力，极大的提高工作效率。
- 后处理器例如：PostCSS，通常被视为在完成的样式表中根据CSS规范处理CSS，让其更有效；目前最常做的是给CSS属性添加浏览器私有前缀，实现跨浏览器兼容性的问题。
二十三、Oracle
Oracle数据库面试练习题
1．列出至少有一个员工的所有部门。
分析：每个部门有多少员工 —— 根据部门编号进行分组
select deptno,count(*) from emp group by deptno having count(*) >= 1;
2．列出薪金比“SMITH”多的所有员工。
分析：先查询出SMITH工资 ： select sal from emp where ename=’SMITH';
select * from emp where sal > (select sal from emp where ename=’SMITH’);
3．***** 列出所有员工的姓名及其直接上级的姓名。
分析：表自映射，为表起别名，进行关联 t1 表模拟员工表 t2 表保存直接上级信息
select t1.ename 员工姓名, t2.ename 直接上级 from emp t1,emp t2 where t1.MGR = t2.empno;
4．列出受雇日期早于其直接上级的所有员工。
分析：原理和上题类似
select t1.*,t2.hiredate from emp t1,emp t2 where t1.MGR = t2.empno and t1.hiredate < t2.hiredate;
5．列出部门名称和这些部门的员工信息，同时列出那些没有员工的部门。
分析：部门没员工也要显示 — 外连接。无论怎样部门信息一定要显示，通过部门去关联员工
select * from dept left outer join emp on dept.deptno = emp.deptno ;
6．列出所有“CLERK”（办事员）的姓名及其部门名称。
分析：查找job为CLERK 员工姓名和部门名称
员工姓名 emp表
部门名称 dept表
select emp.ename,dept.dname,emp.job from emp,dept where emp.deptno = dept.deptno and emp.job=’CLERK';
7．列出最低薪金大于1500的各种工作。
分析：工作的最低薪金 —- 按工作分组，求最低薪金
select min(sal) from emp group by job;
大于1500 是一个分组条件 — having
select job,min(sal) from emp group by job having min(sal) > 1500;
8．列出在部门“SALES”（销售部）工作的员工的姓名，假定不知道销售部的部门编号。
分析：员工姓名位于 emp 部门名称 dept
select emp.ename from emp,dept where emp.deptno = dept.deptno and dept.dname = ‘SALES';
9．列出薪金高于公司平均薪金的所有员工。
分析：先求公司平均薪金 select avg(sal) from emp;
select * from emp where sal > (select avg(sal) from emp);
10．列出与“SCOTT”从事相同工作的所有员工。
分析：先查询SCOTT : select job from emp where ename =’SCOTT';
select * from emp where ename <> ‘SCOTT’ and job = (select job from emp where ename =’SCOTT’);
11．列出薪金等于部门30中员工的薪金的所有员工的姓名和薪金。
分析：查看部门30 中所有员工薪资列表 select sal from emp where deptno = 30;
select * from emp where sal in (select sal from emp where deptno = 30);
12．列出薪金高于在部门30工作的所有员工的薪金的员工姓名和薪金。
分析：
select * from emp where sal > all(select sal from emp where deptno = 30);
select * from emp where sal > (select max(sal) from emp where deptno = 30);
13．列出在每个部门工作的员工数量、平均工资。
分析：按部门分组
select deptno, count(*),avg(sal) from emp group by deptno;
14．列出所有员工的姓名、部门名称和工资。
分析：
select emp.ename,dept.dname,emp.sal from emp,dept where emp.deptno = dept.deptno;
15．列出所有部门的详细信息和部门人数。
分析：
select dept.*,count(emp.*) from emp,dept where emp.deptno = dept.deptno group by deptno ; 错误！
求各个部门编号和人数 select deptno,count(*) from emp group by deptno;
再和dept表关联 select dept.*,temp.部门人数 from dept , (select deptno,count(*) 部门人数 from emp group by deptno) temp where dept.deptno = temp.deptno ;
16．列出各种工作的最低工资。
分析：各个工作 分组 ， 最低工资 min
select job,min(sal) from emp group by job;
17．列出各个部门的MANAGER（经理）的最低薪金。
分析：where job=’MANAGER’ 过滤所有不是经理数据
select deptno,min(sal) from emp where job =’MANAGER’ group by deptno;
18．列出所有员工的年工资,按年薪从低到高排序。
分析： select ename, sal*12 from emp order by sal*12 asc;
19.查出emp表中薪水在3000以上（包括3000）的所有员工的员工号、姓名、薪水。
分析： select * from emp where sal >= 3000;
20.查询出所有薪水在’ALLEN’之上的所有人员信息。
分析：select * from emp where sal > (select sal from emp where ename =’ALLEN’);
21.查询出emp表中部门编号为20，薪水在2000以上（不包括2000）的所有员工，显示他们的员工号，姓名以及薪水，以如下列名显示：员工编号 员工名字 薪水
分析： select empno 员工编号,ename 员工姓名 ,sal 薪水 from emp where deptno = 20 and sal > 2000;
22.查询出emp表中所有的工作种类（无重复）
分析： select distinct job from emp;
23.查询出所有奖金（comm）字段不为空的人员的所有信息。
分析：不为空 is not null
select * from emp where comm is not null;
24.查询出薪水在800到2500之间（闭区间）所有员工的信息。（注：使用两种方式实现and以及between and）
分析：select * from emp where sal >= 800 and sal <= 2500;
select * from emp where sal between 800 and 2500;
25.查询出员工号为7521，7900，7782的所有员工的信息。（注：使用两种方式实现，or以及in）
分析：select * from emp where empno in(7521,7900,7782);
select * from emp where empno=7521 or empno = 7900 or empno = 7782;
26.查询出名字中有“A”字符，并且薪水在1000以上（不包括1000）的所有员工信息。
分析： 模糊查询
select * from emp where ename like ‘%A%’ and sal > 1000;
27.查询出名字第三个字母是“M”的所有员工信息。
分析：第三个字母 __M%
select * from emp where ename like ‘__M%';
28.将所有员工按薪水升序排序，薪水相同的按照入职时间降序排序。
分析：select * from emp order by sal asc,hiredate desc;
29.将所有员工按照名字首字母升序排序，首字母相同的按照薪水降序排序。
分析：SUBSTRING(‘字符串’,第几个字符,长度); —- 首字母 substring(ename,1,1)
select * from emp order by substring(ename,1,1) asc,sal desc;
30.查询出最早工作的那个人的名字、入职时间和薪水。
分析：最早工作人 — hiredate 最小值
select ename,hiredate,sal from emp where hiredate = (select min(hiredate) from emp);
select ename,hiredate,sal from emp where hiredate <= all(select hiredate from emp);
> any === > min
> all === > max
< any === < max
< all === < min
31.显示所有员工的名字、薪水、奖金，如果没有奖金，暂时显示100.
分析：select ename,sal,comm from emp; —- 没有奖金显示100 函数ifnull
select ename,sal,ifnull(comm,100) from emp;
32.显示出薪水最高人的职位。
分析: select job from emp where sal = (select max(sal) from emp);
select job from emp where sal >= all(select sal from emp);
33.查出emp表中所有部门的最高薪水和最低薪水，部门编号为10的部门不显示。
分析：按部门分组 select deptno,max(sal),min(sal) from emp where deptno<>10 group by deptno;
34.删除10号部门薪水最高的员工。
分析：delete from emp where deptno=10 and sal >= all(select sal from emp where deptno=10 ); // MYSQL 不支持
Mysql 规范，修改或者删除 表中记录，不允许在子查询中 查询相同表
ERROR 1093 (HY000): You can’t specify target table ’emp’ for update in FROM clause
解决方案：临时表
delete from emp where deptno=10 and sal >= all(select t.sal from (select sal from emp where deptno=10) t );
35.将薪水最高的员工的薪水降30%。
分析：update emp set sal = sal*0.7 where sal = (select max(sal) from emp); // MYSQL 不支持
引入 临时表
update emp set sal = sal*0.7 where sal = (select t.maxsal from (select max(sal) maxsal from emp) t);
36.查询员工姓名，工资和 工资级别(工资>=3000 为3级，工资>2000 为2级，工资<=2000 为1级)
分析：
select ename,sal, case when sal>=3000 then ‘3级’ when sal>2000 then ‘2级’ else ‘1级’ end 级别 from emp;
语法：case … when … then … when … then … else … end
行列互换
姓名 课程 分数
张三 语文 74
张三 数学 83
张三 物理 93
李四 语文 74
李四 数学 84
李四 物理 94
想变成(得到如下结果)：
姓名 语文 数学 物理
—- —- —- —-
李四 74 84 94
张三 74 83 93
——————-
select name,max(case when cource =’语文’ then score else 0 end) from scores group by name;
select name,max(case when cource =’语文’ then score else 0 end) 语文,max(case when cource =’数学’ then score else 0 end) 数学,
max(case when cource =’英语’ then score else 0 end) 英语 from scores group by name;
Oracle常见面试题
1、对数据库SQL2005、ORACLE熟悉吗？
SQL2005是微软公司的数据库产品。是一个RDBMS数据库，一般应用在一些中型数据库的应用，不能跨平台。
ORACLE是ORACLE公司的数据产品，支持海量数据存储，支持分布式布暑，支持多用户，跨平台，数据安全完整性控制性能优越，是一个ORDBMS，一般用在大型公司。
2、能不能设计数据库？如何实现数据库导入与导出的更新
使用POWERDISINE工具的使用，一般满足第三范式就可以了。EXP与IMP数据库的逻辑导入与导出
3、如何只显示重复数据，或不显示重复数据
显示重复：select * from tablename group by id having count(*)>1
不显示重复：select * from tablename group by id having count(*)=1
4、什么是数据库的映射
就是将数据库的表与字段对应到模型层类名与属性的过程.
5、写分页有哪些方法，你一般用什么方法？用SQL语句写一个分页？
如何用存储过程写分页？
在SQLSERVER中使用TOP分页，在ORACLE中用ROWNUM，或分析函数ROW_NUMBER
使用TOP：
select top 20,n.* from tablename n minus select top 10,m.* from tablename m
使用分析函数：
select * from
(select n.*,row_number() over(order by columnname) num from tablename n)
where num>=10 and num <=20;
使用过程时，只要将分页的范围用两个参数就可以实现。在ORACLE中，要将过程封装在包里，还要用动态游标变量才能实现数据集的返回。
6、ORACLE中左连接与右连接
左连接：LEFT JOIN 右连接：RIGHT JOIN
select n.column,m.column from tablename1 n left join tablename2 m
on n.columnname=m.columnname
用WHERE实现：
select n.column,m.column from tablename1 n， tablename2 m
where n.columnname(+)=m.columnname
7、什么是反射、序列化、反序列化？事务有几种级别？
反射是在程序运行时动态访问DDL的一种方式。序列化是将对象对二进制、XML等方式直接向文件的存储。反序列化是将存储到文件的对象取出的过程。事务的级别的三种：页面级、应用程序级、数据库级。
8、数据测试如何测试？
在PLSQL里对过程或函数可能通过专用的测试工具，通过对
9、用事务的时候，如果在业务逻辑层中，调用数据库访问层中的方法，访问层中有很多类，类又有很多方法，每个方法都要实现，那么如何处理？
通用数据访问层的实现
10、什么时候会用到触发器
A安全管理、B日志管理、C复杂业务逻辑实现
11、如何在数据库中显示树控制？
用父ID与子ID来实现
12、如何实现数据库的优化？
A、调整数据结构的设计。这一部分在开发信息系统之前完成，程序员需要考虑是否使用ORACLE数据库的分区功能，对于经常访问的数据库表是否需要建立索引等。
B、调整应用程序结构设计。这一部分也是在开发信息系统之前完成，程序员在这一步需要考虑应用程序使用什么样的体系结构，是使用传统的Client/Server两层体系结构，还是使用Browser/Web/Database的三层体系结构。不同的应用程序体系结构要求的数据库资源是不同的。
C、调整数据库SQL语句。应用程序的执行最终将归结为数据库中的SQL语句执行，因此SQL语句的执行效率最终决定了ORACLE数据库的性能。ORACLE公司推荐使用ORACLE语句优化器（Oracle Optimizer）和行锁管理器（row-level manager）来调整优化SQL语句。
D、调整服务器内存分配。内存分配是在信息系统运行过程中优化配置的，数据库管理员可以根据数据库运行状况调整数据库系统全局区（SGA区）的数据缓冲区、日志缓冲区和共享池的大小；还可以调整程序全局区（PGA区）的大小。需要注意的是，SGA区不是越大越好，SGA区过大会占用操作系统使用的内存而引起虚拟内存的页面交换，这样反而会降低系统。
E、调整硬盘I/O，这一步是在信息系统开发之前完成的。数据库管理员可以将组成同一个表空间的数据文件放在不同的硬盘上，做到硬盘之间I/O负载均衡。
F、调整操作系统参数，例如：运行在UNIX操作系统上的ORACLE数据库，可以调整UNIX数据缓冲池的大小，每个进程所能使用的内存大小等参数。
二十四、Mysql
1、如何登陆mysql数据库
mysql -u username -p
2、如何开启/关闭mysql服务
service mysql start/stop
3、查看mysql的状态
service mysql status
4、如何显示数所有数据库
show databases
5、如何获取表内所有字段对象的名称和类型
describe table_name;
6、MYSQL支持事务吗？
在缺省模式下，MYSQL是autocommit模式的，所有的数据库更新操作都会即时提交，所以在缺省情况下，mysql是不支持事务的。
但是如果你的MYSQL表类型是使用InnoDB Tables 或 BDB tables的话，你的MYSQL就可以使用事务处理,使用SET AUTOCOMMIT=0就可以使MYSQL允许在非autocommit模式，在非autocommit模式下，你必须使用COMMIT来提交你的更改，或者用ROLLBACK来回滚你的更改。
示例如下：
START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summmary=@A WHERE type=1;
COMMIT;
7、MYSQL相比于其他数据库有哪些特点？
MySQL是一个小型关系型数据库管理系统，开发者为瑞典MySQL AB公司，现在已经被Sun公司收购，支持FreeBSD、Linux、MAC、Windows等多种操作系统与其他的大型数据库例如Oracle、DB2、SQL Server等相比功能稍弱一些
1、可以处理拥有上千万条记录的大型数据
2、支持常见的SQL语句规范
3、可移植行高，安装简单小巧
4、良好的运行效率，有丰富信息的网络支持
5、调试、管理，优化简单（相对其他大型数据库）
8、varchar和char的区别
Char是一种固定长度的类型，varchar是一种可变长度的类型
9、数据库事物有哪几种？
隔离性、持续性、一致性、原子性
10、请简洁地描述下MySQL中InnoDB支持的四种事务隔离级别名称，以及逐级之间的区别？
SQL标准定义的四个隔离级别为：
read uncommited：读取未提交内容
read committed：读取提交内容
repeatable read：可重读
serializable：可串行化
详细解释如下：
Read Uncommitted（读取未提交内容）
在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。
Read Committed（读取提交内容）
这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。
Repeatable Read（可重读）
这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读（Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control 间隙锁）机制解决了该问题。注：其实多版本只是解决不可重复读问题，而加上间隙锁（也就是它这里所谓的并发控制）才解决了幻读问题。
Serializable（可串行化）
这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。
对于不同的事务，采用不同的隔离级别分别有不同的结果。不同的隔离级别有不同的现象。主要有下面3种现在：
1、脏读（dirty read）：一个事务可以读取另一个尚未提交事务的修改数据。
2、非重复读（nonrepeatable read）：在同一个事务中，同一个查询在T1时间读取某一行，在T2时间重新读取这一行时候，这一行的数据已经发生修改，可能被更新了（update），也可能被删除了（delete）。
3、幻像读（phantom read）：在同一事务中，同一查询多次进行时候，由于其他插入操作（insert）的事务提交，导致每次返回不同的结果集。
不同的隔离级别有不同的现象，并有不同的锁定/并发机制，隔离级别越高，数据库的并发性就越差，4种事务隔离级别分别表现的现象如下表：
11、mysql数据库引擎MyISAM和InnoDB的区别
12、mysql有关权限的表都有哪几个
MySQL服务器通过权限表来控制用户对数据库的访问，权限表存放在mysql数据库里，由mysql_install_db脚本初始化。这些权限表分别user，db，table_priv，columns_priv和host。下面分别介绍一下这些表的结构和内容：
user权限表：记录允许连接到服务器的用户帐号信息，里面的权限是全局级的。
db权限表：记录各个帐号在各个数据库上的操作权限。
table_priv权限表：记录数据表级的操作权限。
columns_priv权限表：记录数据列级的操作权限。
host权限表：配合db权限表对给定主机上数据库级操作权限作更细致的控制。这个权限表不受GRANT和REVOKE语句的影响。
13、mysql存储引擎有哪些？如何修改mysql存储引擎？
MyISAM indexed sequential access method (有索引的顺序访问方法)
MyISAM 具有检查和修复表格的大多数工具。表格可以被压缩，而且支持全文收索
不是事务安全的，而且不支持外键。
MEMORY 也是以前的(HEAP) 该类型表存储在内存中，表的索引是哈希分布的。
merge 这些表为了查询目的，把myisam 表集合作为单个表，因此你可以在某些操作系统中避开最大文件大小的限制。
archive 这种类型的表只支持，insert ,select 不支持delete,update,replace ,不使用索引。
csv 这些表保存在服务器的单个文件中，它包含了用逗号间隔的数据。
innodb 这种表是事务安全的。提供了commit（提交） rollback（实务回滚）支持外键，比myisam慢。
修改mysql存储引擎alter table tablename type = innodb;
14、MYSQL 数据表修复及数据恢复面试题
MYSQL数据表在什么情况下容易损坏？
服务器突然断电导致数据文件损坏。
强制关机，没有先关闭mysql 服务等。 数据表损坏后的主要现象是什么？
从表中选择数据之时，得到如下错误：Incorrect key file for table: ‘…’. Try to repair it
查询不能在表中找到行或返回不完全的数据。
Error: Table ‘p’ is marked as crashed and should be repaired 。
打开表失败： Can’t open file: ‘×××.MYI’ (errno: 145) 。 数据表损坏的修复方式有哪些？
使用 myisamchk 来修复，具体步骤：
1）修复前将mysql服务停止。
2）打开命令行方式，然后进入到mysql的/bin目录。
3）执行myisamchk –recover 数据库所在路径/*.MYI
使用repair table 或者 OPTIMIZE table命令来修复，REPAIR TABLE table_name 修复表 OPTIMIZE TABLE table_name 优化表 REPAIR TABLE 用于修复被破坏的表。
OPTIMIZE TABLE 用于回收闲置的数据库空间，当表上的数据行被删除时，所占据的磁盘空间并没有立即被回收，使用了OPTIMIZE TABLE命令后这些空间将被回收，并且对磁盘上的数据行进行重排（注意：是磁盘上，而非数据库）
15、MYSQL数据库服务器性能分析的方法命令有哪些?
Show status
一些值得监控的变量值：
Bytes_received和Bytes_sent
和服务器之间来往的流量。
Com_*服务器正在执行的命令。
Created_*在查询执行期限间创建的临时表和文件。
Handler_*存储引擎操作。
Select_*不同类型的联接执行计划。
Sort_*几种排序信息。
Show session status like ‘Select’;
Show profiles
SET profiling=1;
Show profiles\G
Show profile;
16、 mysql里记录货币用什么字段类型好
NUMERIC和DECIMAL类型被MySQL实现为同样的类型，这在SQL92标准允许。他们被用于保存值，该值的准确精度是极其重要的值，例如与金钱有关的数据。当声明一个类是这些类型之一时，精度和规模的能被(并且通常是)指定；例如：
salary DECIMAL(9,2)
在这个例子中，9(precision)代表将被用于存储值的总的小数位数，而2(scale)代表将被用于存储小数点后的位数。因此，在这种情况下，能被存储在salary列中的值的范围是从-9999999.99到9999999.99。在ANSI/ISO SQL92中，句法DECIMAL(p)等价于DECIMAL(p,0)。同样，句法DECIMAL等价于DECIMAL(p,0)，这里实现被允许决定值p。MySQL当前不支持DECIMAL/NUMERIC数据类型的这些变种形式的任一种。这一般说来不是一个严重的问题，因为这些类型的主要益处得自于明显地控制精度和规模的能力。
DECIMAL和NUMERIC值作为字符串存储，而不是作为二进制浮点数，以便保存那些值的小数精度。一个字符用于值的每一位、小数点(如果scale>0)和“-”符号(对于负值)。如果scale是0，DECIMAL和NUMERIC值不包含小数点或小数部分。
DECIMAL和NUMERIC值得最大的范围与DOUBLE一样，但是对于一个给定的DECIMAL或NUMERIC列，实际的范围可由制由给定列的precision或scale限制。当这样的列赋给了小数点后面的位超过指定scale所允许的位的值，该值根据scale四舍五入。当一个DECIMAL或NUMERIC列被赋给了其大小超过指定(或缺省的）precision和scale隐含的范围的值，MySQL存储表示那个范围的相应的端点值。
Oracle与MySQL的几点区别
1.组函数用法规则
mysql中组函数在select语句中可以随意使用，但在oracle中如果查询语句中有组函数，那其他列名必须是组函数处理过的，或者是group by子句中的列否则报错
eg：
select name,count(money) from user；这个放在mysql中没有问题在oracle中就有问题了。
2.自动增长的数据类型处理
MYSQL有自动增长的数据类型，插入记录时不用操作此字段，会自动获得数据值。ORACLE没有自动增长的数据类型，需要建立一个自动增长的序列号，插入记录时要把序列号的下一个值赋于此字段。
CREATE SEQUENCE序列号的名称(最好是表名+序列号标记)INCREMENT BY 1 START WITH 1 MAXVALUE 99999 CYCLE NOCACHE;
其中最大的值按字段的长度来定，如果定义的自动增长的序列号NUMBER(6)，最大值为999999
INSERT语句插入这个字段值为：序列号的名称.NEXTVAL
3.单引号的处理
MYSQL里可以用双引号包起字符串，ORACLE里只可以用单引号包起字符串。在插入和修改字符串前必须做单引号的替换：把所有出现的一个单引号替换成两个单引号。
4.翻页的SQL语句的处理
MYSQL处理翻页的SQL语句比较简单，用LIMIT开始位置，记录个数；PHP里还可以用SEEK定位到结果集的位置。ORACLE处理翻页的SQL语句就比较繁琐了。每个结果集只有一个ROWNUM字段标明它的位置，并且只能用ROWNUM<100，不能用ROWNUM>80。
以下是经过分析后较好的两种ORACLE翻页SQL语句(ID是唯一关键字的字段名)：
语句一：
SELECT ID, [FIELD_NAME,...] FROM TABLE_NAME WHERE ID IN ( SELECT ID FROM (SELECT ROWNUM AS NUMROW, ID FROM TABLE_NAME WHERE 条件1 ORDER BY 条件2) WHERE NUMROW > 80 AND NUMROW < 100 ) ORDER BY 条件3;
语句二：
SELECT * FROM (( SELECT ROWNUM AS NUMROW, c.* from (select [FIELD_NAME,...] FROM TABLE_NAME WHERE 条件1 ORDER BY 条件2) c) WHERE NUMROW > 80 AND NUMROW < 100 ) ORDER BY 条件3;
5.长字符串的处理
长字符串的处理ORACLE也有它特殊的地方。INSERT和UPDATE时最大可操作的字符串长度小于等于4000个单字节，如果要插入更长的字符串，请考虑字段用CLOB类型，方法借用ORACLE里自带的DBMS_LOB程序包。插入修改记录前一定要做进行非空和长度判断，不能为空的字段值和超出长度字段值都应该提出警告，返回上次操作。
6.日期字段的处理
MYSQL日期字段分DATE和TIME两种，ORACLE日期字段只有DATE，包含年月日时分秒信息，用当前数据库的系统时间为SYSDATE，精确到秒，或者用字符串转换成日期型函数TO_DATE(‘2001-08-01’,’YYYY-MM-DD’)年-月-日24小时:分钟:秒的格式YYYY-MM-DD HH24:MI:SS TO_DATE()还有很多种日期格式，可以参看ORACLE DOC.日期型字段转换成字符串函数TO_CHAR(‘2001-08-01’,’YYYY-MM-DD HH24:MI:SS’)
日期字段的数学运算公式有很大的不同。MYSQL找到离当前时间7天用DATE_FIELD_NAME > SUBDATE(NOW()，INTERVAL 7 DAY)ORACLE找到离当前时间7天用 DATE_FIELD_NAME >SYSDATE - 7;
MYSQL中插入当前时间的几个函数是：NOW()函数以`'YYYY-MM-DD HH:MM:SS'返回当前的日期时间，可以直接存到DATETIME字段中。CURDATE()以’YYYY-MM-DD’的格式返回今天的日期，可以直接存到DATE字段中。CURTIME()以’HH:MM:SS’的格式返回当前的时间，可以直接存到TIME字段中。例：insert into tablename (fieldname) values (now())
而oracle中当前时间是sysdate
7.空字符的处理
MYSQL的非空字段也有空的内容，ORACLE里定义了非空字段就不容许有空的内容。按MYSQL的NOT NULL来定义ORACLE表结构，导数据的时候会产生错误。因此导数据时要对空字符进行判断，如果为NULL或空字符，需要把它改成一个空格的字符串。
8.字符串的模糊比较
MYSQL里用字段名like%‘字符串%’，ORACLE里也可以用字段名like%‘字符串%’但这种方法不能使用索引，速度不快，用字符串比较函数instr(字段名，‘字符串’)>0会得到更精确的查找结果。
9.程序和函数里，操作数据库的工作完成后请注意结果集和指针的释放。
二十五、JSP四种会话跟踪技术
JSP四种会话跟踪技术？
一、Cookie：服务器在一个应答首部传递给浏览器的名称/值对。浏览器保存的时间由cookie的过期时间属性来指定。当浏览器向某个服务器发送一个请求时，它会检查其保存的cookie，并在请求首部中包含从同一台服务器上接收到的所有cookie。
二、Session tracking:在浏览器和服务器之间不直接传送所有的状态信息，而只是传递表示符（session ID）。浏览器发送sessionID,服务器跟踪与该会话相关联的所有信息。传递sessionID可以通过cookie和URL复写技术，大部分容器都支持这两种技术。服务器无法分辨用户是否关闭了浏览器，因此关闭浏览器意味着与先前的会话关联的所有会话数据都保留在服务器上，直到会话超时，服务器销毁会话对像。
®跟踪同一会话中的请求的会话ID可以有多种方法，主要有cookie和url复写。
三、URL复写：把会话ID编码在URL中。
例：counter.jjsp;jsessionnid=be8d697876787876befdbde898789098980
这样，即使浏览器不支持cookie，也能够实现会话跟踪。
对于URL复写，服务器从请求的URI中提取出会话ID，并把该请求与相应的会话关联起来，然后在访问会话数据的时候，JSP页面所进行的处理方式就和使用cookie跟踪会话id时所使用的方式完全相同。所以sesssion的实现要依靠cookie或URL复写技术。
如果想为不支持cookie的浏览器提供会话跟踪，就必须使用行为对应用程序中的所有URL进行复写。这意味着应用程序中的所有页面（至少是那些带有对其他页面引用的页面）都必须是JSP页面，这样页面引用才能以动态方式进行编码，如果遗漏了一个ur，那么服务就会失去对会话的跟踪。
四、隐藏表单域：隐藏表单域是将会话ID添加到HTML的隐藏表单中(类型为hidden的input)。
重定向和转发
可以使用两种方法来调用另一个页面，重定向和转发。
i) 转发：
转发,JSP容器将使用一个内部方法来调用目标页面，新的页面继续处理同一个请求，而浏览器不会知道这个过程涉及到了多个页面。浏览器URL会保持不变。
ii) 重定向:
重定向与转发不同，重定向时，第一个页面会通知浏览器发送一个新的目标页面的请求。浏览器所显示的URL会变成新页面的URL。
重定向的速度比转发要慢，因为浏览器得发出一个新的请求。
同时，由于重定向产生了一个新的请求，所以经过一次重定向之后请求作用域内的对象将无法再使用了。
My Java 总结相关推荐
- springboot实现SSE服务端主动向客户端推送数据，java服务端向客户端推送数据，kotlin模拟客户端向服务端推送数据
SSE服务端推送 服务器向浏览器推送信息,除了 WebSocket,还有一种方法:Server-Sent Events(以下简称 SSE).本文介绍它的用法. 在很多业务场景中,会涉及到服务端向客户端 ...
- Java 获取当前时间之后的第一个周几，java获取当前日期的下一个周几
Java 获取当前时间之后的第一个周几,java获取当前日期的下一个周几 //获得入参的日期 Calendar cd = Calendar.getInstance(); cd.setTime(date ...
- 在k8s中使用gradle构建java web项目镜像Dockerfile
在k8s中使用gradle构建java web项目镜像Dockerfile FROM gradle:6-jdk8 AS build COPY --chown=gradle:gradle . /home ...
- Java | kotlin 手动注入bean，解决lateinit property loginService has not been initialized异常
kotlin.UninitializedPropertyAccessException: lateinit property loginService has not been initialized ...
- SpringBoot项目使用nacos，kotlin使用nacos，java项目使用nacos，gradle项目使用nacos，maven项目使用nacos
SpringBoot项目使用nacos kotlin demo见Gitte 一.引入依赖 提示:这里推荐使用2.2.3版本,springboot与nacos的依赖需要版本相同,否则会报错. maven ...
- OpenAPI使用（swagger3），Kotlin使用swagger3，Java使用swagger3，gradle、Maven使用swagger3
OpenAPI使用(swagger3) demo见Gitte 一.背景及名词解释 OpenAPI是规范的正式名称.规范的开发工作于2015年启动,当时SmartBear(负责Swagger工具开发的公 ...
- Gradle错误提示:Java home supplied via ‘xxx.xxx.xxx‘ is invalid
Gradle错误提示:Java home supplied via 'org.gradle.java.home' is invalid 描述:在使用idea采用gradle进行依赖的管理功能,当想切换 ...
- 查看Hotspot源码，查看java各个版本源码的网站，如何查看jdk源码
java开发必知必会之看源码,而看源码的第一步则是找到源码
- java基本类型转换，随记
java基本类型转换: double double 转 long double random = Math.round(Math.random()*10000); long l = new Doubl ...
- 科学处理java.lang.StackOverflowError: null异常
java.lang.StackOverflowError: null异常处理 在项目运行中出现StackOverflowError 首先要检查在编码中是否有明显的递归编码,比如死循环或者无限循环调用. ...
最新文章
- POJ3264[线段树]
- 把表格的一列生成数组
- Nginx实用指南V1 (连载之四：流行CMS博客rewrite写法)
- Qt 控件渐变隐藏消失
- PHP安全基础第一章
- s4-介质访问控制子层-1 MAC子层
- python之Map函数 reduce 函数
- 一个非常好用的文字滚动的案例，鼠标悬浮可暂停
- python编程实例
- java转码工具应用程序_java转码工具native2ascii.exe的使用方法
- natapp软件使用
- 两台电脑之间使用ntp做时间同步的总结
- 传统数据与大数据安装服务器系统的对比
- 查理芒格推荐的100个思维模型
- MessageBox confirm弹框确认和取消按钮的使用-回调
- 机房收费系统之思想性总结
- vue 拖拽功能样式优化
- 【SpringCloud】SpringCloud简介
- 13-1 IO流 ---- File类的使用（2）常用方法
- 物联网设备和应用程序涉及协议的概述
热门文章
- 温哥华岛大学计算机科学,温哥华有哪些知名大学排名（温哥华地区大学排名一览）...
- iOS 9.3.5 越狱
- ubuntu 安装osx 主题 转自linux公社
- Win10下载和安装FPGA软件：Quartus Prime( Standard 版本18.1)
- 大学C语言 算法的定义及特点教案,第2章 算法的概念和特性介绍_福州大学数计学院：C语言程序设计（韩晓芸）_ppt_大学课件预览_高等教育资讯网...
- 融云CTO杨攀：以技术为先导 全面聚焦“互联网通信云”
- python粒子特效_初试PyOpenGL四 (Python+OpenGL)GPU粒子系统与基本碰撞
- linux ntfs 安装教程,Linux NTFS文件系统安装教程
- 迷你助手世界隐私条款
- ionic3 disabled