Java学习总结模板(3个周一次)

时间：2024.3.31

Java学习总结

注：每3个周做一次总结。

第二篇：java学习个人总结

1. JAVA基础... 1

2. 设计模式... 7

3. 面向对象... 10

4. 常用类... 12

5. 集合... 13

6. 异常... 14

7. IO流... 15

8. HTML. 16

9. CSS. 19

10. Javascript 20

11. AJAX.. 25

12. Json. 28

13. AJAX和json的实例... 31

14. Jquery. 34

15. EasyUI 36

16. JDBC. 36

17. Servlet+Jsp+JavaBean整合开发... 38

18. 案例ajax+easyui+jsp+servlet+javabean. 52

19. WebService. 60

20. Struts2. 60

21. hibernate. 61

1. JAVA基础

1.1 变量的语法

? variable has to be declared and initialized before use

? scope of variables.

? variable can be initialized only ONCE

1.2 八种基本数据类型

byte, short, int, long

float, double,

char

boolean

1.3 数据类型转换

(1)自动类型转换

(2)强制类型转换

自动类型转换分两种情况：1，不同类型的数据进行运算时，系统会自动将运算优先级别低的转换成级别高的，结果和运算级别高的数据类型一样。2，赋值运算符两边类型不一样时，系统会自动将右侧表达式的类型转换成左侧的变量类型，然后再赋值

强制类型转换：

如：（int）3.1415 //就是取整数部分

（int）a%10 //取a的个位数

1.4 方法

16.1 方法由返回值，方法名，参数，内容组成。

16.2 一般方法由类所创建的对象调用，类不直接调用。

16.3 形参和实参

void speak(String name){ //形参，入参

system.out.println("我叫"+name)

}

public static void main(String[] args){

People zhangsan=new People();

zhangsan.speak("张三"); //实参

}

16.4 方法有没有返回值的方法(void)，和有返回值的方法

int calculate(String ... hobbies){

for(String hobby:hobbies){

system.out.println(hobby+"");

}

int totalHobbies=hobbies.length;

return totalHobbies;

}

public static void main(String[] args){

People zhangsan=new People();

int n=zhangsan.calculate("唱歌","跳舞","游泳");

system.out.println("\n有"+n+"个爱好");

}

16.5 方法的值传递和引用传递

值传递，传的是数值;而引用传递传的是对象(即相当于地址，和c里面的指针一样)

java中为了避免引用传递出错，使用static关键字，使得对象无法二次赋值，而发生错误。

如：

public class sanwei{

static int h;//长

static int w;//重

static int k;//宽

}

public class Person {

int age;

void speak(int age,sanwei sw){

System. out.println( "我今年"+age+"岁了，我的三围是" +sw.h+"," +sw.w+"," +sw.k);

age=24;

sanwei. h=18;

}

public static void main(String[] args){

// TODO Auto-generated method stub

Person xiaoming= new Person();

int age=22;

sanwei sw= new sanwei();

sw. h=90;

sw. w=60;

sw. k=90;

//age传递的是值，而 sanwei传递的是引用(地址)，c里面叫指针

xiaoming.speak(age,sw);

System. out.println(age);

System. out.println(sw. h);

}

16.6 方法的重载

方法的名称,返回值相同，但是参数的类型和参数的个数不同，java的多态性的重要体现。

String类型转化为int型：Integer.parseInt(b) //如b="3"就会转化为3

16.7 static静态方法和普通方法

static方法:一般是工具类方法

static方法：方法属于类本身，调用方式：1.类名.方法(绝大部分情况) 2.对象.方法(不建议这么使用)

普通方法：方法属于类的对象，调用方式：1.对象.方法

如：

public class Deom{

void fun1(){}

static void fun2(){}

public static void main(String[] args){

Demo demo=new Demo();

//调用普通方法

demo.fun1();

//调用静态方法

Deom.fun2();

}

16.8 递归方法：方法通过直接或间接的方式调用自己

有一个循环体，一个终止条件

如：int DiGui(int n,int result){

if(n==1){

return 1;

}else{

result=result*n;

n--;

}

return result;

}

16.9 构造方法

创建实例时，进行初始化的作用，没有返回值，和类名一样。

this关键字，表示当前对象，this可以调用本类中的属性和构造方法。(防止构造方法，内部重名，如this.name=name比name=name看上去好很多，不至于那么莫名其妙)

如：

public class Student(){

private int id;

private String name;

private String sex;

//构造方法

Student(){

this.id=id;

this.name=name；

this.sex=sex；

}

1.5 运算符

5.1自增运算

先计算 ++ 运算，再赋值，最后进行 ++。

如:后 ++ 运算: a++。

1 int a=1; int b;

2 int b = a++;

1. 取 a 的值为 1，作为 a++ 表达式的值为 1

2. 将 a 的值增加 1， a 为 2

3. 执行赋值运算，将 a++ 的值 1 赋给 b,b 为 1

5.2复合赋值运算

sum+=i 与 sum=sum+i 等同。

5.3逻辑运算

1.6 流程控制

6.1 if…esle…

6.2 switch

1. switch 的条件只能是 byte char short int 类型，不能是 long

或其它类型。

2. case 只能是整数（byte char short int）常量或字面量，如 ‘中’，但不

能是表达式或变量。

1. 遇到 break; 后跳过后面的 case 语句。

6.3 while

6.4 for

在 for 循环中，先执行初始化（1），再判断布尔表达式（2），再执行循环体（3），

再递增表达式（4） …

1 for(initialization(1);boolean-expression(2);step(4)) {

2 statement(3)

3 }

for(;;) 与 while(true) 等效。

6.5 foreach

对数组与集合的循环可以使用 foreach 语句 (也叫增强 for循环)。

public class ForEachFloat {

public static void main(String[] args) {

Random rand = new Random(47);

float f[] = new float[10];

for(int i = 0; i < 10; i++)

f[i] = rand.nextFloat();

for(float x : f)

System.out.println(x);

}

1.7 数组

7.1数组变量的声明

int[] apples; // 声明数组变量 apples, 数组变量是代词

7.2 数组变量的初始化

int[] apples = new int[]{1,3,5};

7.3 数组变量的引用

数组变量通过内存地址引用数组对象。

如: JSD 的同学们不要吸烟了，他们不听话

同学们及他们（变量）引用了JSD的全体同学(对象)

1.8 简单算法

8.1选择排序

void SelectSortArray()
{
    int min_index;
    for(int i=0;i<n-1;i++)
    {
         min_index=i;
         for(int j=i+1;j<n;j++)//每次扫描选择最小项
            if(arr[j]<arr[min_index])

min_index=j;
         if(min_index!=i)//找到最小项交换，即将这一项移到列表中的正确位置
         {
             int temp;
             temp=arr[i];

arr[i]=arr[min_index];

arr[min_index]=temp;
}
}
}

8.2冒泡排序

public class bubbleSort {
public static void main(String[] args) {
  int temp;
  int [] arr={2,4,5,9,7,6};

  //循环遍历,循环的次数为n-1次
  for(int i=0;i<arr.length-1;i++){
//和前面的元素比较n-1-i次
for(int j=0;j<arr.length-1-i;j++){
  //假如前面的数大于后面的数，就交换数据
  if(arr[j]>arr[j+1]){
  temp=arr[j];
  arr[j]=arr[j+1];
  arr[j+1]=temp;
  }
}
  }

  for(int i:arr){
System.out.println(i+" ");
  }
}
}

8.3插入排序

void InsertSortArray()
{

//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分
for(int i=1;i<n;i++)
{
int temp=arr[i];//temp标记为未排序第一个元素
int j=i-1;
while (j>=0 && arr[j]>temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/
{
arr[j+1]=arr[j];
j--;
}
arr[j+1]=temp;
}
}

8.4 递归算法

递归方法：方法通过直接或间接的方式调用自己

必须有一个循环体，一个终止条件，归调用过程中不断地在栈内存中声明变量，因此递归效率较低。递归层次较多时可能产生内存溢出。

如：下面一个阶乘的算法，

int DiGui(int n,int result){

int result=1;

if(n==1){

return 1;

}else{

result=result*n;

n--;

}

return result;

}

2. 设计模式

1. 什么是设计模式

建筑工地上，工人在盖房子，但是你看不到制造砖的人。

在汽车厂房里，你看到的是组装汽车的人，而不是制造零件的人。

在软件开发中，UI设计师，系统分析师，代码人员。

因此一些专家就把他们在解决某一问题的过程中积累的一些经验进行总结。以帮助后来的人更好地掌握从抽象到具体的方法。这就是设计模式。

2. UML

3. 面向对象设计的几个基本原则

A.单一职责；

系统中的每一个对象应该只有一个单独的职责，所有对象关注的是自身职责的完成。

基本思想：高内聚，低耦合。

B.里氏替换原则；

在任意父类出现的地方，都可以使用子类来替代。（子类具备父类所不具有的功能）

C. 依赖注入原则；

要依赖于抽象，不要依赖于具体的实现。

基本思想：在开发中尽量的面向接口编程。

D.接口分离原则；

不要去使用一些不需要使用的功能。

基本思想：一个接口不要提供太多的行为。

E.迪米一个对象对其他的对象应该尽可能少的了解。

基本思想：降低耦合。特原则；

F. 开闭原则；

一个对象对扩展开放，对修改关闭。

基本思想：对类的改动是通过增加代码进行的，而不是修改现有的代码。

G优先使用组合而不是继承原则；

基本思想：在复用对象的时候，要优先考虑组合，而不是继承。

把相关的方法放在一个类中，方便使用，如数据库的连接，关闭等等操作可以放到一个Util类中

4. 设计模式

(1)创建型模式：创建对象。（单例，工厂模式）

(2)结构行模式：对象的组成及对象的关系。（代理模式）

(3)行为型模式：对象的行为。对象能够做什么。

5. 创建型模式

(1)工厂方法模式

当创建对象比较简单的时候，可以直接在mian里面做，但是很多时候创建对象操作会比较复杂，这个时候就可以通过工厂模式来解决。

(2)单例模式

保证类在内存中只有一个对象。应用：数据库中的连接池，Runtime类

如何保证类在内存中只有一个对象呢？

A.构造方法私有，不让外界创建对象。

B．在类中去创建一个对象。

C.通过一个公共的访问方式给外界提供一个入口。

例如：

以下程序中类一加载，对象就创建了，所以也被称为饿汉式单例模式。

Student类：

public class Student {

//为了不让外界访问，我们将构造方法私有。

private Student(){

}

//创建一个对象，为了满足静态方法访问，这里也加了一个静态修饰符

private static Student s=new Student();

//提供一个公共的访问方式，静态类型，为了让外界直接访问

public static Student getStudent(){

return s;

}

public void show(){

System.out.println("我爱java");

}

测试类：

public class StudentTest {

public static void main(String[] args) {

//通过单例模式获取对象，并调用方法

Student s1=Student.getStudent();

Student s2=Student.getStudent();

//返回true的话，就表示满足单例模式的条件

System.out.println(s1==s2);

s1.show();

s2.show();

}

另外有一种，称为懒汉式单例模式。延迟加载思想，就是我们什么时候需要对象，你就什么时候给我们对象。 (Hibernate加载)

public class Teacher {

//为了不让外界创建对象，把构造方法私有

private Teacher(){

}

//本类创建一个对象

//加static是为了保证静态方法可以访问

//加private是为了保证外界不能直接访问

private static Teacher t=null;

//提供公共的访问方式

//访问的时候才创建，精髓所在

//synchronized关键字，解决线程同步问题，被同步的代码，在某一时刻只能在一个线程访问

public synchronized static Teacher getTeacher(){

if(t==null){

t=new Teacher();

}

return t;

}

//写了一个方法

public void love(){

System.out.println("喜欢");

}

public class TeacherTest {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

Teacher t1=Teacher.getTeacher();

Teacher t2=Teacher.getTeacher();

System.out.println(t1==t2);

}

那么开发中一般采用哪种方案呢，一般采用第一种，原因：多线程安全问题，第二种的话，比如有t1和t2同时来访问，那么这个时候，当t1进来以后，判断这个时候t是null，所以t1就进去执行if所控制的语句。但是，由于线程的随机性，可能当t1刚进去执行if所控制的语句时，t2就抢到了cpu的执行权。这个时候，t2就开始执行了，发现这个时候t还是null，所以t2也进去执行if所控制的语句了。那么将来会有多个对象被创建。

6. 装饰模式

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

给一个对象增加新的功能有2种方法,第一个面向对象:继承，第二个装饰模式。

举例子：IO流

方案一：通过继承的话，如果后期要求增加的功能太多，继承体系就会越来越大，臃肿。

方案二：装饰模式应运而生。

编写一个装饰者把所有的输入流内的大写字符转化成小写字符：

import java.io.FilterInputStream;

import java.io.IOException;

import java.io.InputStream;

public class LowerCaseInputStream extends FilterInputStream

{

protected LowerCaseInputStream(InputStream in)

{

super(in);

}

@Override

public int read() throws IOException

{

int c = super.read();

return (c == -1 ? c : Character.toLowerCase((char) c));

}

@Override

public int read(byte[] b, int offset, int len) throws IOException

{

int result = super.read(b, offset, len);

for (int i = offset; i < offset + result; i++)

{

b[i] = (byte) Character.toLowerCase((char) b[i]);

}

return result;

}

测试我们的装饰者类：

import java.io.*;

public class InputTest

{

public static void main(String[] args) throws IOException

{

int c;

try

{

InputStream in = new LowerCaseInputStream(new BufferedInputStream(

new FileInputStream("D:\\test.txt")));

while ((c = in.read()) >= 0)

{

System.out.print((char) c);

}

in.close();

}

catch (IOException e)

{

e.printStackTrace();

}

3. 面向对象

1. 类与对象

类就是一组表示属性的数据与一系列用于访问、操作这些属性的方法。

类的成员（即类的属性与方法）可以分为两种：

（1）static静态成员，即类成员，它们描述了类本身的特征。可以通过类名直接访问。

（2）非静态成员，即实例成员、对象成员，它们描述了对象个体的特征。必须先实例化，然后通过实例化的对象名去访问。

注意：类的属性会自动初始化，但局部变量需要手动初始化。

2. 构造方法

构造方法（constructor）用来描述对象的创建过程，它具有两大特征：

? 方法名与类名必须相同，且不能有返回值类型

? 支持方法重载。

3. java的变量类型

基本类型(8种)和引用类型

引用变量与对象的创建过程：

1. 在栈内存中分配空间，存放引用变量

2. 在堆内存中分配空间，存放创建出来的对象

3. 引用对象保存的是堆内存中对象的句柄（地址，不是物理地址）

4. 类型转换

? 向上转型 (upcasting)：隐式／自动类型转制，即小类型到大类型，或

子类型到父类型的转换。

? 向下转型 (downcasting)：强制类型转换，即大类型到小类型的转换。

如：

Dog dog=(Dog) animal

5. 对象的实例化过程

1. 加载 class 文件

2. 在堆内存中分配内存空间，递归分配所有父类与子类的实行空间

3. 进行属性赋值

4. 递归调用父类构造器（默认调用父类无参构造器）

5. 调用本类的构造器

6. 继承

子类继承了父类的所有方法。每一个子类只有一个父类。这使得 Java 的类

呈树状结构，所有的类的根都为 Object。这使 Java 的继承关系简单清晰，

但无法获得多个父类的属性。为获得多个类的方法或属性， Java 允许一个类

有多个接口。

7. super(), this()

作用：减少代码的重复率

? 在构造函数中，同一个类中可以有多个构造函数（重载），构造函数之间可通过 this(...) 的方式相互调用。但须防止构造方法之间形成死循环，即防止构造方法相互间的错误调用。注意： this() 的语句只能在构造函数的第一行出现。

? 在构造函数中， super(...) 也只能在构造函数的第一行出现。如果在构造方法中未写 super(...) 语句时，系统自动调用 super() 语句。

? 任何子类一定至少有一个构造函数调用父类的构造函数。

8. 方法重写／覆盖

9. 修饰符

三种 public protect private

10. 封装

private 修饰符为对象封装提供语法基础。声明属性时应尽可能地使用私有，最大程序地对属性进行封装，在需要时可使用访问方法 (getter,setter) 适当地开放属性的访问权。

11. 多态

一个对象的在不同情景下表现的不同形态被称为多态。继承关系是对象多态的基础。

12. 抽象与接口

抽象 (abstract) 类不能实例化，含有抽象方法的类称为抽象类。它的子类必须实现所有抽象类中定义的所有抽象方法。

接口（interface）是一种特殊的抽象类，但与抽象类不同，

（1）接口类的所有方法都是抽象类型，即自动添加 abstract。

（2）接口没有实例属性，所有属性都是 public static final 型。

（3）接口没有构造方法。

（4）一个类可以同时实现（implements）多个接口。

13. 静态方法

被 static 修饰的方法就是静态方法，静态方法与对象无关，是类的方法。同样，此方法不需要创建当前类的实例就可被调用。

静态方法只在当前类加载的时候执行一次， JVM 第一次使用这个类时，会读取当前类的 class 文件载入内存，这时会执行静态代码块。

14. final关键字

final 关键字可以修饰类、属性、方法。

用 final 修饰的类不能被继承。 Java 的 String， Math 等都是final属性的类。

final 修饰的方法不能被子类覆盖。final 修饰的属性必须赋初值，且不能被修改。 final 可以修饰局部变量以及方法参数，效果与对属性的约束相同。

15. abstract关键字

抽象方法只有方法的声明，没有方法的实现。

1. 使用 abstract 关键字的方法，即抽象方法，不能含有方法体。

2. 含有抽象方法的类只能是抽象类。

3. 抽象类不能被实例化，但可以用来声明对象（见下例）。

4. 抽象类可以用非抽象方法，普通属性，及构造方法。

5. 抽象类只能被继承。一个非抽象类如果继承了抽象类，那么它必须实

现其父类中的所有抽象方法。

6. 抽象方法和抽象类非常适合做系统分析与设计的工具。

16. interface关键字

接口是一种特殊的抽象类：

1. 接口只能包含抽象方法与常量（即全部使用 public， final, static）。

2. 接口定义使用 interface 关键字声明。

3. 在接口中可以不用写出 abstract 关键字，系统会自动添加。

接口通过 implements 实现，一个类可以对多个接口类实现。一个类与被实现的接口也是继承关系。

17. javaBean

JavaBean 规范不是针对语法的规范，而是对编程习惯的指导规范，使用这个规范写的类使用方便，JavaBean 的要求包括：

1. 必须有包

2. 类必须有无参数的构造器

3. 类必须使用 set 与 get 方法声明的属性

a) 针对一般属性而言，使用 get 与 set 方法。

b) 针对 boolean 类型的属性，一般采用 isXxx() 的方法。

4. 必须实现序列化接口

4. 常用类

Java 的基本特性：

1. 封装性：类的封装性为类的成员提供公有、缺省、保护和私有等多级访

问权限，目的是隐藏类中的私有变量和类中方法的实现细节。

2. 继承性：类的继承性提供从已存在的类创建新类的机制，继承（inheritance）

使一个新类自动拥有被继承类（父类）的全部可继承的成员。

3. 多态性：类的多态性提供类中方法执行的多样性，多态性有两种表现形

式：重载和覆盖。

1. Object 类

Java中所有的类都直接或间接地是Object类的子类，所有的类都有Object 类定义的方法，如 toString，equals，clone，hashCode 等。

2. String类(如何使用API)

字符串的使用相当频繁，String 提供了很多方便对字符串操作的方法。String 内部仍使用 char[] 的方式保存字符串。

由于String是普通对象(不是8种基本数据类型)，所以传递的是引用。

3. 内部类

5. 集合

Collection是一个接口，定义了集合相关的抽象方法。 Collection 下面有两大子接口， List与 Set。

1. 集合（Set）

Set中可以保存任意类型实例（集合中每个元素是任意类型实例），但一般而言，一个集合的元素类型应该是一致的，Set 元素无序, 且不能重复添加Set为无序集合，它也有 add, remove 等方法，但因其无序性，它没有 List的根据下标操作的相关方法。

2. List 元素有序，且可重复添加

3. ArrayList

1. add

2. toString： ArrayList 重写了 toString 方法，即调用各元素的 toString

方法，如 aryList[index].toString()。 nn

3. contains：调用各元素的 equals 方法，查看是否含有相同的元素。

4. remove(Object o)：将集合中的元素与 o 用 equals 比较，如果返

回 true 就删除。删除成功后返回 true。

5. remove(int index)：将集合中的 index 处的元素删除。删除成功

后返回被删除的对象，且返回对象的类型为 Object。

6. size：返回当前集合中的元素数量。

7. set(int index, Object o)：将 index 处的元素替换为 o，并返

回被替换的元素。

8. get(int index)：返回 index 处的元素。

9. addAll(Collection c)：将集合 c 中的元素全部添加到当前集合

的末尾。－合集

10. removeAll(Collection c)：将当前集合中所有 c 中的元素全部

删除。－差集

11. retainAll(Collection c)：保存当前集合与 c 共有的元素。－合

集12. isEmpty：判断当前集合是否为空。－空集

13. clear：将集合中的元素清空。

4. LinkList

链表采用双向循环链表实现，适于需要频繁增删元素的列表。除下面的方法外，它的方法大多与 ArrayList 的相同。可以参考API文档。

5. HashMap

HashMap 是以 key-value 的形式存放数据的。

key 可以是任意对象，且key不允许重复。

value 可以是任意对象

6. 泛型

Java5 开始提供的一个新特性：泛型。编译器使用泛型约束集合中元素

的类型（运行期间不检查）。这样的好处是：

? 向集合中存放元素时类型统一

? 从集合中取出元素时，不需要使用 Casting

语法： LinkedList<Node> nodes = new LinkedList<Node>();

7. 集合的迭代

集合的迭代是对集合元素的一种遍历方法。 Java 中使用 Iterator （迭代

器）来描述迭代模式操作。 Iterator 中的迭代算法是专为 while 循环设计

的。 Iterator 可以通过任何集合对象获取。

如：

Itertator<Student> it=list.iterator();

while(it.hasNext()){

Student s=it.next();

system.out.println("姓名："+s.getName()+"年龄："+s.getAge());

}

6. 异常

异常是程序运行时出现的错误,异常需要捕获,否则下面的语句无法运行

(1). try{} catch(Exception e){ e.printStackTrace();}finally{ }

其中finally必须要执行.

(2).throws和throw关键字

用throws直接把异常抛出,不处理

用throw直接new出一个异常,是自定义的

(3).Exception和RuntimeException的区别

Exception是检查型异常,例如: Exception在程序中必须用try..catch进行处理

RuntimeException是非检查型异常,例如:NumberFormatException,可以不用try..catch进行处理，如果有异常由JVM进行处理。

(4).自定义异常类:项目中自己定义的

//自定义异常

Public class CustomException extends Exception{

//构造方法

Public CustomException(String message){

Super(message);

}

7. IO流

1. 什么是IO流

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称和抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据传输的特性将流抽象为各种类，方便更直观的进行数据操作。

2. 分类(依据处理数据的类型不同)

字符流(read，write)和字节流(InputStream和OutputStream)

3. 文件操作File类

(1)创建目录文件

(2)创建文件

(3)删除文件

8. HTML

1. html

Hyper Text Markup Language 即文本标记语言，后缀为.html 或.htm,

用浏览器解释运行。当源文件有错误时，浏览器仍试图解释。因此不同浏览

器可能会出现不同的结果。

2. head区域

head 中包含整个文档的定义，如 title 即文档标题，与单标记的元数据。

head 中还包括 link, style, script.

3. body区域

body 即页面的主体内容，它包括文本，表格，图像与超级链接，及表单与框

架。

4. 常用标记

使用默认格式时，

? 标题 <h1> 到<h6>

? 段落 <p>...</p>

? 换行 <br>

5. span, div

? 同一行元素分组，不影响其它布局 span

? 多行元素分组，会自动换行 div

<span> 在CSS定义中属于一个行内元素,在行内定义一个区域，也就是一行内可以被 <span> 划分成好几个区域，从而实现某种特定效果。 <span> 本身没有任何属性。 <div> 在CSS定义中属于一个块级元素 <div> 可以包含段落、标题、表格甚至其它部分。这使DIV便于建立不同集成的类，如章节、摘要或备注。在页面效果上，使用 <div> 会自动换行，使用 <span> 就会保持同行。

6. a

? 超级链接 <a href=”dest-loc”>Text</a>; 超链接的属性包括

– target: 可以使用_self 或 _blank 在当前或新页面打开目标链

接。

– name: 用于定义锚点，便于在页面的不同位置之间跳转。使用锚

点时，应在它的前面添加#.

– title: 用于设置当鼠标移动到链接上时，显示的提示信息

– href=javascript:jsFunction();

7. img

? 添加图像单标记<img src=”img-loc”>

8. table

? 表格用于显示结构化数据或实现页面的布局 table/tr/td

– table properties: border, width, height, cellpadding, cellspacing

– td properties: width, height, align, valign

– 行分组 thead/tbody/tfoot

– caption 默认居中 <caption>Caption text</caption>

? 不规则表格 rowspan, colspan

<tr>

<th>第一个元素</th>

<th>第二个元素</th>

<th>第三个元素</th>

</tr>

<tr>

</tr>

<tr>

</tr>

</table>

9. form

表单用于收集用户提供的数据并提交给服务器。 form 元素用于承载页面的控件，以表单为单位，将当前表单中的数据提交给服务器。

form 的常用属性有

? action,method 点击后以 method 中定义的方式提交给服务器，并

进行 action 所定义的操作

9.1 form 的元素

? input 为单标记，通过 type 定义不同的类型：

1. 默认为文本框 (text)

2. password

3. checkbox，使用 name 属性便于服务器获取值；使用 checked

设置默认选择状态。

4. radio，使用 name 属性将 radio 分组

5. value 用于设置 text 与 password 类型的默认值；或设置 checkbox 与 radio 的关键数据，通常是 id 的数据。

? button

1. submit 使用 value 更改名称

2. reset 使用 value 更改名称

3. button 依赖 onclick 进行操作

4. file 用于上传文件

5. hidden 用于记录隐藏类信息，如用户在服务上的唯一 ID 值

? 非 input 元素的标记成对出现，在各对标记之间设置默认值。

1. textarea 用 rows,cols 设置文本框的大小

2. select 必须包含 option 元素。 select 的 size 属性用于设置默认选项展开的行数。 selectedIndex 用于查看当前所选项的索引（第一项索引值为 0）。

3. fieldset 即域集合，用于将表单的内容区分到一个区域。

4. legend 为加载到当前fieldset中的说明信息，必须作为fieldset的第一个元素出现。

<form>

username:<input type="text" value="aaa" name="username" id="username1"><br>

password:<input type="password"><br>

兴趣:旅游<input type="checkbox"> 看书<input type="checkbox"><br>

性别:男<input type="radio" name="gender"> 女<input type="radio" name="gender"><br>

学历：<select>

</select><br>

评论：<textarea></textarea><br>

文件上传：<input type="file">

&nbsp；&nbsp；&nbsp；

</form>

10. 列表

常用于菜单类的内容

1. 有序列表 ol

Ordered List:

<ol>

</ol>

2. 无序列表 ul

Unodered List:

<ul>

</ul>

3. 列表项 li

11. select 与 option

</select>

12. frame

框架中用的最多的是 iframe，它可以将一个页面嵌入另一个页面。常用于实现广告页面的效果。

9. CSS

传统 HTML 中各个元素关于样式定义的属性不统一，数据和表现未分离，可维护性差。

CSS 解决了统一定义的问题：font-size:20pt;color:red;

1. CSS语法：一个选择器selector，一个属性和一个值

例如： (1) selector {property：value}

body {color:black}

(2)多个属性

p{text-align:center; color:red}

(3)多个选择器用逗号隔开

h1,h2,h3,p{color:black}

2. 三种样式定义

样式定义必须有选择器（selector，即样式内容前的 h1, p, div 等）。

(1)将 CSS 写入 <style> 中的方式称为内联方式。

(2)将 CSS 样式写入<head> 中的<style> 里（内部样式表），这样做仍没有实现样式与内容分离。

(3)把 CSS 样式写入样式文档（外部样式）：

不同的样式编写方式可以共用，建议使用最后一种，即将样式写入文本中。

使用多种方式时，将对同一元素的样式合并，当样式中的属性有冲突时，采用就近原则选择。

3. 类选择器(基本都用此选择器)

类选择器：以”.”开头的(主要用类选择器)

html中：<p class="right">this is xxx</p>

css中引用：p.right{text-align:center};

html中<p class="right">this is xxx</p>

css中引用：.right{text-alig:right};(更加具有通用性，只要class属性中有right都采用此样式)

4. id选择器：

以“#”开头的，id要唯一(最好这样，符合规范)

html中：<h1 id="green">some text</h1>

css中引用：#green{color:green}

5. 样式属性

5.1 border

边框属性包括宽度、线型及颜色：

border:1px solid red;

border-top:1px dashed blue;

border-bottom;

5.2 display

display 属性用于设置元素的显示方式：

1. none 使元素不可见，且不占用空间，常用于设置初始不可见的元素

2. inline 使元素以行内元素的方式出现

3. block 使元素以块级元素的方式出现

5.3 position

position 属性

1. 默认使用流模式显示页面

2. static

3. absolute 相对于父元素的坐标进行偏移

4. relative 相对于当前元素原来的坐标进行偏移

10. Javascript

JavaScript 是一种脚本语言，由浏览器解释运行，常用于添加客户端的动态效果。 JavaScript 内置了大量对象，支持数据的简单封装、抽象。

可使用到 JS 的现象有

? 验证数据录入

? 页面的动态效果

? 浏览器的交互

脚本里的字符串使用双引号或单引号引用。

javascript是一种弱类型

1. javascript引入方式

两种引入方式，外部和内部

2. 注释

单行 // 多行 /* */

3. javascript变量

弱类型，用var来定义变量

例如：

var a=1;

document.write("a="+a+"<br/>");

</script>

4. javascript的基本数据类型

整型和浮点型直接var a=1；var b=1.2；

字符型加双引号，var c="我是射手"；

布尔型， var d=ture；

不定义类型 var e；

5. 常用的内置对象

5.1 String

var s=”newstring”;

5.2 Array

var a = [”mary”, 123, treu];

5.3 Date

var date = new Date(”20##-01-29 12:10:10”);

5.4页面显示

通常不使用 alert 的方式通知用户，使用 span 的 innerHTML 属性将结果直接显示在页面上。

如：

function inlineDisplay(){

var sum=0;

for(var i=0;i<arguments.length;i++)

sum+=arguments[i];

var obj = document.getElementById(”hidSumNum”);

obj.inlineHTML=(”Sum of ”+arguments.toString+” is ”+sum);

}

6. javascript的运算符

（1）加减乘除；

（2）赋值；

（3）比较；

（4）逻辑运算符：与，或，非

7. 选择语句和循环语句

if..else switch for循环 while和do{ } while

8. javascript的函数（重要）

例子：

fuction fun1(param1,param2){

alert(param1+""+param2);

}

fun1(ni，hao)；

9. javascript的DOM节点（重要）

Document Object Model 将 HTML 文档作为一个节点树的结构。

（1）javascript处理DOM事件

<head>

function fun1(){

alert( "点我做什么" );

}

</ script>

</head>

<body>

< input type= "button" value = "点我一次" onclick ="fun1()" >

</body>

（2）javascript操作DOM节点(修改，添加，删除)

<head>

function modifyDOM(){

<!--通常不用 alert 通知用户，使用 span 的 innerHTML 将结果直接显示在页面上-- >

document.getElementById("txt").innerHTML="用户名：";

document.getElementById("userName").value="Jack";

}

function addDOM(){

var para=document.createElement("p");

var node=document.createTextNode("...前...");

var para2=document.createElement("p");

var node2=document.createTextNode("...后...");

para.appendChild(node);//在para后面追加node

para2.appendChild(node2);

var parent=document.getElementById("parent");

var son1=document.getElementById("son1");

parent.insertBefore(para, son1);//在son1节点前面加

parent.appendChild(para2);

}

function removeDOM(){

var parent=document.getElementById("parent");

var son1=document.getElementById("son1");

parent.removeChild(son1);

}

</script>

</head>

<body>

</div>

</body>

（3）javascript修改DOM节点的css样式

<head>

10. javascript的BOM结点

Browser Object Model 将窗口的各部分封装为树形结构的对象，包括window, document, location, history, screen, navigator, event。

10.1 window

代表整个窗口，其它对象都是它的子类。

(1) open(url)

window.open(url,name,config);

返回新的窗口对象 newWindow。默认打开多个窗口，如果希望只打开一个窗口， name 变量。使用 config定义新窗口的高与宽。

(2) confirm

confirm会根据用户的点击返回一个boolean值

function confirmMsg(t){

return window.confirm(t);

}

</script>

(3) alert

(4) prompt

prompt 是文本输入的对话框，返回用户的输入，如果无输入则返回null。

var result = window.prompt(”Enter user name:”);

alert(result);

if(result==null || result==” ”)

return false;

else

return true;

(5) setInterval

每隔多少时间执行一个函数。参数的单位是毫秒。注意 function 名后无括号。

timer = window.setInterval(function,time);

11. javascript的高级特性

(1) JavaScript自定义对象

创建对象方式：方式一，对象初始化器方式；方式二，构造函数方式；

<body>

<%--方式一：对象初始化--%>

var marry={

name:"marry",

age:2,

shout:function(){

alert("我是："+this.name+",今年："+this.age);

action:function(){

alert("会吃");

}

};

alert(marry.name);

alert(marry.age);

marry.shout();

marry.action();

<%--方式二：构造方法--%>

function Dog(name,age){

this.name=name;

this.age=age;

this.shout=function(){

alert("我是："+this.name+",今年："+this.age);

};

this.action=function(){

alert("会吃");

};

}

var jack=new Dog("jack",1);

alert(jack.name);

alert(jack.age);

jack.shout();

jack.action();

</script>

</body>

(2) JavaScript实现封装特性

(3) JavaScript实现继承特性

(4) JavaScript实现多态特性

11. AJAX

关于ajax的原理，我就简单介绍一下呗：通过javascript的方式，将前台数据通过xmlhttp对象传递到后台，后台在接收到请求后，将需要的结果，再传到前台，这样就可以实现不需要页面的回发，从而使页数据实现来回传递，实现无刷新的效果。

1. 简介

(1)AJAX(异步的javascript和XML)，是一种创建交互式的网页应用的网页开发技术。

(2) AJAX是异步交互，局部刷新。

(3) AJAX可以减少服务器的压力。

(4) AJAX能提高用户体验。

2. Ajax交互与传统交互的比较

3. XMLHttpRequest对象的创建

所有现代浏览器均支持 XMLHttpRequest 对象（IE5 和 IE6 使用 ActiveXObject）。

XMLHttpRequest 用于在后台与服务器交换数据。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。

<head>

function loadName(){

var xmlHttp;

<!—主流浏览器-->

if(window.XMLHttpRequest){

xmlHttp=new XMLHttpRequest();

<!—IE5或者IE6-->

}else{

xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");

}

</script>

</head>

<body>

</div>

</body>

4. XMLHttpRequest 对象请求后台

请求后台的方法 open() (打开)和send()(将请求发送给服务器)

步骤：

(1).前台js请求

<head>

function loadName(){

var xmlHttp;

if(window.XMLHttpRequest){

xmlHttp=new XMLHttpRequest();

}else{

xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");

}

<%--三个参数 method,url,是否同步--%>

<%--打开请求，其中getAjaxName对应着web.xml中的servlet，交由此servlet处理，web的核心也在于此处。--%>

xmlHttp.open("get","getAjaxName?name=jack&age=11", true);

<%--将请求发送给后台服务器--%>

xmlHttp.send();

}

</script>

</head>

(2)后台servlet

public class GetAjaxNameServlet extends HttpServlet {

private static final long serialVersionUID = 1L;

@Override

protected void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

// TODO Auto-generated method stub

this.doPost(request, response);

}

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String name=request.getParameter("name");

String age=request.getParameter("age");

response.setContentType("text/html;charset=utf-8");

//创建一个页面打印流对象，便于下面的局部刷新调用

PrintWriter out=response.getWriter();

out.println("ajax的返回文本");

out.flush();

out.close();

}

(3)配置web.xml web程序的入口

<servlet-name>getAjaxNameServlet</servlet-name>

<servlet-class>com.qzp.web.GetAjaxNameServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>getAjaxNameServlet</servlet-name>

<!—与ajax中的url保持一致-->

<url-pattern>/getAjaxName</url-pattern>

</servlet-mapping>

xmlHttp的方法

(1) open(method,url,async) (打开请求)

备注：ajax一般都是异步的(true)

规定请求的类型、URL 以及是否异步处理请求。

method：请求的类型；GET 或 POST

url：文件在服务器上的位置

async：true（异步）或 false（同步）

(2) send(string) 将请求发送到服务器。

string：仅用于 POST 请求

GET 还是 POST？

与 POST 相比，GET 更简单也更快，并且在大部分情况下都能用。

然而，在以下情况中，请使用 POST 请求：

无法使用缓存文件（更新服务器上的文件或数据库）

向服务器发送大量数据（POST 没有数据量限制）

发送包含未知字符的用户输入时，POST 比 GET 更稳定也更可靠

(3) 异步 - True 或 False？

AJAX 指的是异步 JavaScript 和 XML（Asynchronous JavaScript and XML）。

为 True 的话，表示的是异步，异步表示程序请求服务器的同时，程序可以继续执行；能提高系统的运行效率；

为 False 的话，表示同步，JavaScript 会等到服务器响应就绪才继续执行。如果服务器繁忙或缓慢，应用程序会挂起或停止。

我们一般都是用 True；

5. XMLHttpRequest 对象响应服务器(服务器接收到请求，并响应)

(1) onreadystatechange 事件：当请求被发送到服务器时，我们需要执行一些基于响应的任务。每当readyState改变时，就会触发onreadystatechange 事件。readyState 属性存有 XMLHttpRequest 的状态信息。

下面是XMLHttpRequest对象的三个重要的属性：

①onreadystatechange存储函数（或函数名），每当 readyState 属性改变时，就会调用该函数。

②readyState存有 XMLHttpRequest 的状态。从 0 到 4 发生变化。

0: 请求未初始化

1: 服务器连接已建立

2: 请求已接收

3: 请求处理中

4: 请求已完成，且响应已就绪

③status

200: "OK"

404: 未找到页面

(2) 在onreadystatechange事件中，我们规定当服务器响应已做好被处理的准备时所执行的任务。

如需获得来自服务器的响应，请使用 XMLHttpRequest 对象的 responseText 或 responseXML 属性。

属性描述

responseText 获得字符串形式的响应数据。

responseXML 获得 XML 形式的响应数据。（了解即可）

12. Json

1. JSON的引入

在局部进行刷新的时候，往往不止是一个字符串等简单数据，有时候是复杂的结构。而XML比较繁琐，JSON应运而生。

2. 什么是Json

JavaScript Ojbect Notation (Json) 借鉴了 JavaScript 规范中创建对象一种语法结构，并因此而命名。

var s = {’city’:’bj’,’room’:2008};

Json 是一种轻量级的数据交换标准，它比 XML 解析速度更快，文档结构更简单。

3. Json格式语法

首先是一个键值对的形式，主要可以进行对象，数组等数据的交互标准

(1)JSON对象

{“name” :”张三”，”age”:22}

(2)JSON数组

{

“student”:[

{“name”:”张三”,”age”:22},

{“name”:”李四” , “age”:33},

{“name”:”张三”,”age”:22},

]

}

(3)JSON 嵌套

{

"student": [

{ "name":"张三" , "age":22 ,"score":{"chinese":90,"math":100,"english":80} },

{ "name":"李四" , "age":23 ,"score":{"chinese":70,"math":90, "english":90} },

{ "name":"王五" , "age":24 ,"score":{"chinese":80,"math":60, "english":90} }

]

}

4. AJAX与JSON的交互过程

(1) jsp页面

<html>

<head>

function loadInfo(){

var xmlHttp;

if(window.XMLHttpRequest){

xmlHttp=new XMLHttpRequest();

}else{

xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");

}

/*这个函数只有当xmlHttp.readyState==4 && xmlHttp.status==200成立时才会执行，也就是*服务器接收到请求并且处理完成。

xmlHttp.onreadystatechange=function(){

if(xmlHttp.readyState==4 && xmlHttp.status==200){

//获取xmlHttp.responseText的值,测试之用

alert(xmlHttp.responseText);

//将json串换成JSON对象(js格式) var dataObj=eval("("+data+")");

var dataObj=eval("("+xmlHttp.responseText+")");

alert(dataObj.name);

alert(dataObj.age);

//将xmlHttp.responseText的值，分别赋给下面jsp页面中的name和age

document.getElementById("name").value=dataObj.name;

document.getElementById("age").value=dataObj.age;

}

};

<!—与web.xml中的url保持一致-->

<!—XMLHttpRequest 对象请求后台.

请求后台的方法 open() (打开)和send()(将请求发送给服务器)

-->

xmlHttp.open("get","getAjaxInfo", true);

xmlHttp.send();

}

</script>

</head>

<body>

年龄：<input type="text" id="age" name="age">

</div>

</body>

(2) web.xml

<servlet-name>getAjaxInfoServlet</servlet-name>

<servlet-class>com.qzp.web.GetAjaxInfoServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>getAjaxInfoServlet</servlet-name>

<url-pattern>/getAjaxInfo</url-pattern>

</servlet-mapping>

(3) GetAjaxInfoServlet

public class GetAjaxInfoServlet extends HttpServlet{

private static final long serialVersionUID = 1L;

@Override

protected void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

// TODO Auto-generated method stub

this.doPost(request, response);

}

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

response.setContentType("text/html;charset=utf-8");

PrintWriter out=response.getWriter();

JSONObject resultJson=new JSONObject();

resultJson.put("name", "张三");

resultJson.put("age", 22);

out.println(resultJson);

out.flush();

out.close();

}

13. AJAX和json的实例

(非常重要)二级联动菜单

(1) JSP页面

function loadInfo(){

//获取省的id号

var shengId=document.getElementById("sheng").value;

// 删除所有市下拉框的选项

shi.options.length=0;

var xmlHttp;

if(window.XMLHttpRequest){

xmlHttp=new XMLHttpRequest();

}else{

xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");

}

xmlHttp.onreadystatechange=function(){

if(xmlHttp.readyState==4 && xmlHttp.status==200){

alert(xmlHttp.responseText);

var dataObj=eval("("+xmlHttp.responseText+")");

for(var i=0;i<dataObj.rows.length;i++){

var o=dataObj.rows[i];

shi.options.add(new Option(o.text,o.id));

}

};

xmlHttp.open("get", "getAjaxInfo2?action=ejld&shengId="+shengId, true);

xmlHttp.send();

}

</script>

</head>

<body>

省：

</select>

市

</select>

</body>

</html>

(2) web.xml

<servlet-name>getAjaxInfo2Servlet</servlet-name>

<servlet-class>com.qzp.web.GetAjaxInfo2Servlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>getAjaxInfo2Servlet</servlet-name>

<url-pattern>/getAjaxInfo2</url-pattern>

</servlet-mapping>

(3) 后台交互的servlet

public class GetAjaxInfo2Servlet extends HttpServlet{

private static final long serialVersionUID = 1L;

@Override

protected void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

this.doPost(request, response);

}

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

response.setContentType("text/html;charset=utf-8");

//获取action的值(从前台传入)

String action=request.getParameter("action");

if("checkUserName".equals(action)){

this.checkUserName(request, response);

}else if("ejld".equals(action)){

this.ejld(request, response);

}

private void ejld(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

PrintWriter out=response.getWriter();

String shengId=request.getParameter("shengId");

//键值对形式

JSONObject resultJson=new JSONObject();

JSONArray jsonArray=new JSONArray();

JSONObject temp=null;

switch(Integer.parseInt(shengId)){

case 1:{

temp=new JSONObject();temp.put("id", 1);temp.put("text", "南京");jsonArray.add(temp);

temp=new JSONObject();temp.put("id", 2);temp.put("text", "南通");jsonArray.add(temp);

temp=new JSONObject();temp.put("id", 3);temp.put("text", "泰兴");jsonArray.add(temp);

break;

}

case 2:{

temp=new JSONObject();temp.put("id", 4);temp.put("text", "济南");jsonArray.add(temp);

temp=new JSONObject();temp.put("id", 5);temp.put("text", "烟台");jsonArray.add(temp);

temp=new JSONObject();temp.put("id", 6);temp.put("text", "蓬莱");jsonArray.add(temp);

break;

}

case 3:{

temp=new JSONObject();temp.put("id", 7);temp.put("text", "杭州");jsonArray.add(temp);

temp=new JSONObject();temp.put("id", 8);temp.put("text", "宁波");jsonArray.add(temp);

temp=new JSONObject();temp.put("id", 9);temp.put("text", "温州");jsonArray.add(temp);

break;

}

resultJson.put("rows", jsonArray);

out.println(resultJson);

out.flush();

out.close();

}

14. Jquery

更多参考W3school：http://www.w3school.com.cn/jquery/index.asp

1. 什么是jquery

jQuery 是一个 JavaScript 库。

jQuery 极大地简化了 JavaScript 编程。

2. jquery的特性

l HTML 元素选取

l HTML 元素操作

l CSS 操作

l HTML 事件函数

l JavaScript 特效和动画

l HTML DOM 遍历和修改

l AJAX

l Utilities

3. 向页面添加jquery库

JQuery 库位于一个 JavaScript 文件中，其中包含了所有的 jQuery 函数。

可以通过下面的标记把 jQuery 添加到网页中：

<head>

</head>

4. jquery实例

隐藏了 HTML 文档中所有的 <p> 元素。

(1)按钮的点击事件被触发时会调用一个函数 $("button").click(function()

(2) 该方法隐藏所有 <p> 元素： $("p").hide();

<head>

$(document).ready(function(){

$("button").click(function(){

$("p").hide();

});

</script>

</head>

<body>

<h2>This is a heading</h2>

<p>This is a paragraph.</p>

<p>This is another paragraph.</p>

<button type="button">Click me</button>

</body>

5. jQuery的语法

jQuery语法是为 HTML 元素的选取编制的，可以对元素执行某些操作。

基础语法是：$(selector).action()

美元符号定义 jQuery

选择符（selector）“查询”和“查找” HTML 元素

jQuery 的 action() 执行对元素的操作

示例：

$(this).hide() - 隐藏当前元素

$("p").hide() - 隐藏所有段落

$(".test").hide() - 隐藏所有 class="test" 的所有元素

$("#test").hide() - 隐藏所有 id="test" 的元素

6. 文档就绪函数

您也许已经注意到在我们的实例中的所有 jQuery 函数位于一个 document ready 函数中：

$(document).ready(function(){

--- jQuery functions go here ----

});

这是为了防止文档在完全加载（就绪）之前运行 jQuery 代码。

7. jquery选择器

jquery元素选择器，jquery属性选择器，jquery css选择器

8. jquery的效果(参考W3School)

9. jquery参考手册

http://www.w3school.com.cn/jquery/jquery_reference.asp

15. EasyUI

16. JDBC

16.1 连接数据库

前提：项目中配置数据库驱动，引入包

(1).加载数据库驱动；

Class.forName(驱动名);

(2).连接数据库；

(3).使用语句操作数据库；

(4).关闭数据库，释放资源。

public class DbUtil {

private String dbUrl= "jdbc:mysql://localhost:3306/db_studentInfo" ;

private String dbUserName= "root";

private String dbPassword= "sa";

private String jdbcName= "com.mysql.jdbc.Driver";

/**.

* 获取数据库连接

* @return

* @throws Exception

public Connection getCon() throws Exception{

Class.forName(jdbcName);

Connection con=DriverManager.getConnection(dbUrl,dbUserName,dbPassword);

return con;

}

/**

* 关闭数据库连接

* @param con

* @throws Exception

public void closeCon(Connection con) throws Exception{

if(con!= null){

con.close();

}

16.2 PreparedStatement接口增删改

(1) 增加操作

//首先得获取连接，这边通过参数传入

public int UserAdd(Connection con,User user)throws Exception{

String sql="insert into t_user userName=?,password=? where id=?";

//调用了connection的prepareStatement(String sql)方法

PreparedStatement pstmt=con.prepareStatement(sql);

// 给第一个坑设置值

pstmt.setString(1, user.getUserName());

// 给第二个坑设置值

pstmt.setString(2, user.getPassword());

pstmt.setInt(3, user.getId());

//将执行的查询结果返回给result

int result=pstmt.executeUpdate();

//关闭资源不可少

dbUtil.closeCon(con);

return result;

}

(2) 删除操作

public int UserDelete(Connection con,User user)throws Exception{

String sql="delete from t_user where id=?";

PreparedStatement pstmt=con.prepareStatement(sql);

pstmt.setInt(1, user.getId());

duUtil.closeCon(con);

return pstmt.executeUpdate();

}

(3) 修改操作

public int UserUpdate(Connection con,User user)throws Exception{

String sql="update t_user set userName=?,password=? where id=?";

PreparedStatement pstmt=con.prepareStatement(sql);

pstmt.setString(1, user.getUserName());

pstmt.setString(2, user.getPassword());

pstmt.setInt(3, user.getId());

int result=pstmt.executeUpdate();

duUtil.closeCon(con);

return result;

}

16.3 ResultSet结果集引入进行查找

当我们查询数据库时，返回的是一个二维的结果集，这个时候需要我们使用ResultSet来遍历结果集，获取每一行的数据。

例子如下：

public static List<User> ListUser(Connection con)throws Exception{

//在一般项目中，都是封装在一个ArrayList结果集中再返回

List<User> userList=new ArrayList<User>();

String sql="selete * from t_user";

PreparedStatement pstmt=con.prepareStatement(sql);

ResultSet rs=pstmt.executeQuery();

while(rs.next()){

int id=rs.getInt(1);

String userName=rs.getString(2);

String password=rs.getString(3);

//将查询的结果写入User()构造函数之中

User user=new User(id,userName,password);

//通过ArrayList的add方法，一条一条添加进去

userList.add(user);

}

return userList;

}

public static void main(String[] args) throws Exception {

List<User> userList=new ArrayList<User>();

for(User user:userList){

System.out.println(user);

}

17. Servlet+Jsp+JavaBean整合开发

WEB 前端包括 HTML， CSS， JS。 WEB 后端包括 Servlet, JSP, AJax.

Model 模型层由javabean完成具体的业务逻辑

View 视图层由Jsp完成页面的显示

Controller 控制层Servlet接口类负责从视图读取数据，控制用户输入，并向模型发送数据。

1. JavaBean

(1)主要有两种，一种是有用户界面的UI的javabean，另外一种是没有用户界面的，主要负责处理事务的（如数据运算，操作数据库）javabean。

(2)好处：可以使html和java分离，使得jsp侧重于生成动态网页，事务处理由javabean来完成，

(3).几大特征:

①是一个公共的类(public);

②有一个不带参数的构造方法，可以重载;

③有若干属性，通过set方法设置属性，通过get方法获取属性.

(4)JSP访问javabean的语法(结合下面的案例看)

①导入javabean，jsp开头

<%@ page import ="mypack.CounterBean" %>

②声明javabean对象，实例化

<%- Javabean 的保存范围有 page,request,session.application，默认是 page；-%>

<jsp:useBean id="myBean" class="mypack.CountrtBean" scope="session"/>

其实就相当于 MyBean mybean=new MyBean();

③访问javabean属性

将javabean的某个属性输出到网页上,name属性要和声明时的id保持一致

<jsp:getProperty name="myBean" property="count"/>

给某个javabean属性赋值，

<jsp:setProperty name="myBean" property="count" value="0"/>

④javabean删除

Page范围：pageContext.removeAttribute(“javaBean Name”);

request范围：request.removeAttribute(“javaBean Name”);

session范围：session.removeAttribute(“javaBean Name”);

application范围：application.removeAttribute(“javaBean Name”);

2. Servlet

3.1 什么是servlet

Servlet是指任何实现了这个Servlet接口的类，他继承了HttpServlet，实现了doGet()和doPost()2种方法。Servlet 运行在 tomcat 容器中，并由容器管理从创建到销毁的整个过程。

3.2 servlet的生命周期

(1) 加载和实例化
Servlet 容器装载和实例化一个 Servlet。创建出该 Servlet 类的一个实例。
(2) 初始化
在 Servlet 实例化完成之后，容器负责调用该 Servlet 实例的 init() 方法，在处理用户请求之前，来做一些额外的初始化工作。
(3) 处理请求
当 Servlet 容器接收到一个 Servlet 请求时，便运行与之对应的 Servlet 实例的 service() 方法，service() 方法再派遣运行与请求相对应的
doXX(doGet，doPost) 方法来处理用户请求。
(4) 销毁
当 Servlet 容器决定将一个 Servlet 从服务器中移除时 ( 如 Servlet 文件被更新 )，便调用该 Servlet 实例的 destroy() 方法，在销毁该 Servlet 实例之前，
来做一些其他的工作。
其中，(1)(2)(4) 在 Servlet 的整个生命周期中只会被执行一次。

3.3 Servlet 的工作原理

当客户端浏览器向服务器请求一个Servlet时，服务器收到该请求后，首先到容器中检索与请求匹配的 Servlet 实例是否已经存在。若不存在，则 Servlet 容器负责加载并实例化出该类 Servlet的一个实例对象，接着容器框架负责调用该实例的init()方法来对实例做一些初始化工作，然后Servlet 容器运行该实例的 service()方法。若 Servlet 实例已经存在，则容器框架直接调用该实例的service() 方法。service()方法在运行时，自动派遣运行与用户请求相对应的 doXX() 方法来响应用户发起的请求。
通常，每个Servlet类在容器中只存在一个实例，每当请求到来时，则分配一条线程来处理该请求。

3.4 Servlet过滤器(更多请看下面一章的案例)

主要过滤用户的请求，继承Filter接口(implements Filter)，实现里面的三种方法，并且也要在web.xml中进行配置，比如防止用户非法登陆(不输入用户名，直接输入用户主界面的URL)

3.5 Servlet监听器

监听web事件，比如application，request，session等等比如要监听session要继承HttpSessionAttributeListener接口，实现方法，可以监听他的删除，添加，修改。而且也需要到web.xml中进行配置。

3. JSP

4.1 什么是JSP

JSP的是JAVA SERVLET PAGE，本质也是Servlet，他的运行和servlet一样也需要容器(即Tomcat)的支持。

4.2 JSP的工作原理

4.3 Scriptlet标签

通过scriptlet标签，我们可以在JSP中嵌入java代码

第一种：<%!%> 我们可以在里面定义全局变量，方法，类 (在head中)

第二种：<% %> 我们可以在里面定义局部变量，编写语句(最主要的)

第三种：<%= %> 我们可以在里面输出一个变量和一个具体内容

4.4 JSP 注释

Html 注释客户端可见

<%-- --%> Jsp 注释客户端不可见

// java 单行注释

/* */ java 多行注释

4.5 Jsp包含指令

<%@ include file=”要包含的文件”%> 静态包含先包含，后编译处理；

<jsp:include page=”要包含的文件”> 动态包含先编译处理，后包含，以后开发用动态包含；

4.6 Jsp跳转指令(不要过细理解)

<jsp:forward page=”target.jsp”>

<jsp:param value=”” name=””>

</jsp:forward>

服务器内部跳转，可带参数；

4.7 JSP九大内置对象

(就是不要实例化就可以直接使用，是servlet帮你实例化的)

pageContext，request，response，session，application，config，out，page，exception，前五种要熟练掌握，在JSP中，可以保存数据，JSP提供了四种保存数据的范围，分别是page，request，session，application

4.8 JSP保存数据的四大作用域

主要是request和session用的较多。

(1)Page范围：只在一个页面保存，继承了javax.servlet.jsp.PageContex(抽象类)

<body>

//设置两个page范围的数据 key-> value键值对的形式

pageContext.setAttribute("name", "张三");

pageContext.setAttribute("age", 22);

*取值,范围只在本page页有用，而且取出来的值是object类型，需要向下转型，这个不必

*仔细研究，可以查看API，或者编写过程中，myeclipse会给出提示

String name=(String)pageContext.getAttribute("name");

int age=(Integer)pageContext.getAttribute("age");

</body>

(2)Request范围：只在一次请求中保存数据实现了javax.servlet.HttpServletRequest（接口）

如：

请求页面request.jsp

<body>

//设置两个request的范围

request.setAttribute("name", "张三");

request.setAttribute("age", 11);

<%-JSP服务器内部跳转-%>

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

</body>

另外一个转发页面requestTarget.jsp

<body>

//取值,范围只在一次请求中有效

String name=(String)request.getAttribute("name");

int age=(Integer)request.getAttribute("age");

</body>

(3)Session范围：在一次会话范围中保存数据，范围更大，仅供单个用户使用；保存在服务器端，默认30分钟直到用户关闭浏览器。

(4)Application 范围：在整个服务器上保存数据，所有用户共享，范围最大；

4.9 response对象

Response 内置对象和 request 内置对象是相对应的，response 内置对象用于响应客户请求，向客户端输出信息；

(1).自动刷新应用(了解，使用底层的方法response.setHeader())

(2).页面重定向应用客户端跳转(常用)，与跳转不同，他不能带任何值，也就是只有session，application的值可以传过去，别的值无法传过去。

response.sendRedirect(“index.html”);

(3).操作cookie应用 (存放在客户端)

post get方法比较 post 放数据包里； get数据会跟在URL后面不安全；

如：登陆界面(部分代码，当然还要在head区域获取userLogin.jsp页面创建和保存的cookie值，此处省略，此处主要理解如何用response对象保存一个cookie)：

<table>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

</table>

</form>

UserLogin.jsp页面

<body>

String userName=request.getParameter("userName");

String pwd=request.getParameter("pwd");

String remember=request.getParameter("remember");

if("remember-me".equals(remember)){

//创建一个cookie

Cookie userNameAndPwd=new Cookie("userNameAndPwd",userName+""+pwd);

//cookie记录一个星期

userNameAndPwd.setMaxAge(60*60*24*7);

//保存cookie

response.addCookie(userNameAndPwd);

}

//重定向response.jsp

response.sendRedirect("response.jsp");

</body>

补充：cookie信息是存客户端的，session信息是存服务器的；

4.10 out对象

Out内置对象主要用来向客户端输出各种类型的数据

4.11 EL表达式

(1) 作用:简化JSP开发,使得JSP写起来更加简洁.

(2) EL表达式的主要内置对象(了解)

(3) EL表达式,4种范围属性,取属性省的每次都用getAttribute，直接用${ }

<body>

pageContext.setAttribute("info1", "page范围的值");

request.setAttribute("info2", "request范围的值");

session.setAttribute("info3", "session范围的值");

application.setAttribute("info4", "application范围的值");

</body>

(4) EL表达式接受请求参数，之前用getparamete(“name”)，现在直接用${param.name }

如:请求页面

<body>

<input type="checkbox" name="hobby" value="java语言"/>java语言

<input type="checkbox" name="hobby" value="c语言"/>c语言

<input type="checkbox" name="hobby" value="php语言"/>php语言

</form>

</body>

接受页面：

<body>

<%--设置编码，防止乱码问题--%>

request.setCharacterEncoding("utf-8");

<%--接受用户传入过来的name属性，和getattribute()一样--%>

姓名：${param.name}<br/>

年龄：${param.age }<br/>

<%--接受多个参数--%>

爱好一：${paramValues.hobby[0] }<br/>

爱好二：${paramValues.hobby[1] }<br/>

爱好三：${paramValues.hobby[2] }<br/>

</body>

(5) EL表达式对象操作

首先，创建一个JavaBean。People类，有id，name，age三个属性，此处省略代码

然后，jsp页面中利用EL表达式操作对象

<body>

<%--首先要创建对象，引包不可以少格式：<%@import=" com.qzp.model.*"%>--%>

People zhangsan=new People();

zhangsan.setId(1);

zhangsan.setName("张三");

zhangsan.setAge(20);

//将对象值放入zhangsan中

request.setAttribute("zhangsan", zhangsan);

<h1>编号：${zhangsan.id}</h1>

<h1>姓名：${zhangsan.name }</h1>

<h1>年龄：${zhangsan.age }</h1>

</body>

(6) EL表达式对集合的操作

<body>

List all=new LinkedList();

all.add(0, "元素1");

all.add(1, "元素2");

all.add(2, "元素3");

//将集合值放入zhangsan中

request.setAttribute("all", all);

</body>

(7) EL表达式支持的运算符

算术，关系和三目运算符(num1>num2:yes)

4.12 JSP自定义标签

自己通过tld，进行配置创建自定义标签

4.13 JSTL(JSP标准标签库)

(1) 是什么？

JSTL是(JSP Standard Tag Library，JSP标准标签库)

(2) 使用标签库必须引入标准包(jstl.jar，standard.jar)，里面有很多.tld(标签的描述文件)

在jsp中引用的标准如下：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

(3) JSTL核心标签库

c:out 内容输出标签。如：

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<html>

<head>

</head>

<body>

pageContext.setAttribute("people","张三");

<%--有默认输出，这一方面要强于EL表达式--%>

</body>

</html>

c:set 用来设置 4 中属性范围值(request，session，application..)的标签；

<body>

<c:set var="people" value="张三" scope="request"></c:set>

<%--这边定义了一个model，代码省略，其中scope的默认为page--%>

<jsp:useBean id="people2" class="com.qzp.model.People" scope="page"></jsp:useBean>

<%--给javabean设置值--%>

<c:set property="id" target="${people2 }" value="007"></c:set>

<c:set property="name" target="${people2 }" value="王二小"></c:set>

<c:set property="age" target="${people2 }" value="16"></c:set>

<h2>编号：${people2.id }</h2>

<h2>姓名：${people2.name }</h2>

<h2>年龄：${people2.age }</h2>

</body>

c:remove 用来删除指定范围中的属性；

<body>

<c:set var="people" value="张三" scope="request"></c:set>

<c:remove var="people" scope="request"/>

</body>

c:catch 用来处理程序中产生的异常(了解)；

<c:catch var="errMsg">

int a=1/0;

</c:catch>

<h2>异常信息：${errMsg }</h2>

c:if 用来条件判断；

c:choose、c:when、c:otherwise 用来多条件判断；

c:forEach 用来遍历数组或者集合；

String dogs[]={"小黑","小黄","小白","小小"};

pageContext.setAttribute("dogs",dogs);

<c:forEach var="dog" items="${dogs }">

${dog }

</c:forEach>

<hr/>

<%--默认是跳1步，这边跳2步--%>

<c:forEach var="dog" items="${dogs }" step="2">

${dog }

</c:forEach>

<hr/>

<c:forEach var="dog" items="${dogs }" begin="1" end="2">

${dog }

</c:forEach>

<hr/>

<%--集合的遍历，实践开发中用的很多--%>

List<People> pList=new ArrayList<People>();

pList.add(new People(1,"张三",10));

pList.add(new People(2,"李四",20));

pList.add(new People(3,"王五",30));

pageContext.setAttribute("pList",pList);

<table>

<tr>

</tr>

<%--每个对象p--%>

<c:forEach var="p" items="${pList }">

<tr>

</tr>

</c:forEach>

</table>

c:fortokens 分隔输出(了解)；

c:import 导入页面(类似于jsp:include)；

<body>

<c:import url="c_forEach.jsp"></c:import>

<c:import url="c_if.jsp"></c:import>

</body>

c:url 生成一个 url 地址；

<body>

<c:url value="http://www.java1234.com" var="url">

<c:param name="name" value="xiaofeng"></c:param>

<c:param name="age" value="26"></c:param>

</c:url>

<a href="${url }">Java知识分享网</a>

</body>

c:redirect 客户端跳转

(4) 非核心标签库(了解)

两点，更加清楚的理解MVC，第一点 View层与Controller层的交互，第二点View层是如何与Model层交互的。

非常重要V层到C层 JSP和servlet的交互(理解web程序的本质)

（1）重要的配置文件 web.xml，他是web程序的入口处

<servlet>

<servlet-name>validateServlet</servlet-name>

<servlet-class>com.qzp.web.ValidateServlet</servlet-class>
</servlet>

<servlet-mapping>

<servlet-name>validateServlet</servlet-name>

<url-pattern>/login</url-pattern>
</servlet-mapping>

(2).jsp页面

<body>

username:<input type="text" name="username" id="username1"><br>

password:<input type="password" name="password" id="password1"><br>

repassword:<input type="password" name="repassword" id="repassword1"><br>

</form>

</body>

(3).servlet页面（由web容器Tomcat创建，继承了HttpServlet，实现了doGet()和doPost()2种方法）

public class ValidateServlet extends HttpServlet{

@Override

protected void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

//request.getParameter()方法传递的数据，会从Web客户端传到Web服务器端，代表HTTP请求数据。

String username=req.getParameter("username");

String password=req.getParameter("password");

String repassword=req.getParameter("repassword");

//定义一个集合，存放错误信息

List<String> list=new ArrayList<String>();

if("".equals(username))

{

list.add("username can not be blank!");

}

if(password==null||password.length()<6||password.length()>10)

{

list.add("length of password should be between 6 and 10 ");

}

if(repassword==null||repassword.length()<6||repassword.length()>10)

{

list.add("length of repassword should be between 6 and 10 ");

}

if(password!=null && repassword!=null &&!password.equals(repassword))

{

list.add("password and repassword not the same");

}

if(list.isEmpty()){

*request.getParameter()方法传递的数据，会从Web客户端传到Web服务器端，代表HTTP请求数据。

*request.getParameter()方法返回String类型的数据。

*request.setAttribute()和getAttribute()方法传递的数据只会存在于Web容器内部，在具有转发关系的Web组件之间共享。

req.setAttribute("username", username);

req.setAttribute("password", password);

req.getRequestDispatcher("success.jsp").forward(req, resp);

}

else{

req.setAttribute("error", list);

req.getRequestDispatcher("error.jsp").forward(req, resp);

}

@Override

protected void doPost(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

// TODO Auto-generated method stub

this.doGet(req, resp);

}

(4).jsp通过servlet跳转到其余页面。如：success.jsp，并通过request.getAttribute(),将值带过去，总的来说：request.getAttribute()方法返回request范围内存在的对象，只会存在于Web容器内部，在具有转发关系的Web组件之间共享；而request.getParameter()方法是获取客户端向服务器端提交过来的数据。

<body>

登陆成功<br>

username:<%=request.getAttribute("username") %><br>

password:<%=request.getAttribute("password") %>

</body>

非常重要V层到M层 V层到M层是JSP与JavaBean的交互

JSP访问javabean的语法

(1)导入javabean，jsp开头 <%@ page import ="mypack.CounterBean" %>

(2)声明javabean对象，实例化

<jsp:useBean id="myBean" class="mypack.CountrtBean" scope="session"/>

其实就相当于 MyBean mybean=new MyBean();

(3)访问javabean属性

将javabean的某个属性输出到网页上,name属性要和声明时的id保持一致

<jsp:getProperty name="myBean" property="count"/>

给某个javabean属性赋值，

<jsp:setProperty name="myBean" property="count" value="0"/>

部分代码：

<body>

<!—-id与name保持一致; class里面写的是javabean的路径 -->

<jsp:useBean id="person" class="com.qzp.model.Person"></jsp:useBean>

<jsp:getProperty name="person" property="name"/>

<jsp:setProperty name="person" property="age" value="12"/>

<jsp:getProperty name="person" property="age"/>

</body>

18. 案例ajax+easyui+jsp+servlet+javabean

本例子附带了各层的全部代码。要深刻理解，很重要。

12.1 MVC模式

12.2 数据库创建

创建数据库db_jsp；创建表t_user

12.3 分层思想

(1)Model层：里面是一个Javabean

如：

public class User {

private int id;

private String userName;

private String password;

public User() {

super();

// TODO Auto-generated constructor stub

}

//重写了构造方法

public User(String userName,String password){

super();

this.userName=userName;

this.password=password;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

(2)Dao层：处理数据库的操作

public class UserDao {

* 登录验证

* @param con

* @param user

* @return

* @throws Exception

public User login(Connection con,User user) throws Exception{

User resultUser=null;

String sql="select * from t_user where userName=? and password=?";

PreparedStatement pstmt=con.prepareStatement(sql);

//preparestatement是预编译的，即给第一个坑(userName)设置值为user.getUserName

pstmt.setString(1, user.getUserName());

//第二个坑(password)设置为user.getPassword

pstmt.setString(2, user.getPassword());

/**

*将执行的结果返回给一个rs(结果集)，即从t_user表中查询*userName=user.getUserName()&&password=user.getPassword()的值，

*如果有返回所以的值给rs

ResultSet rs=pstmt.executeQuery();

//如果查询结果中有值，则执行以下语句

if(rs.next()){

resultUser=new User();

//获取结果集中的值，把它赋给resultUser

resultUser.setUserName(rs.getString("userName"));

resultUser.setPassword(rs.getString("password"));

}

return resultUser;

}

(3)Util包：对数据库访问，工具类包的简单封装

如：简单的数据库访问工具包

public class DbUtil {

private String dbUrl="jdbc:mysql://localhost:3306/db_jsp";

private String dbUserName="root";

private String dbPassword="sa";

private String jdbcName="com.mysql.jdbc.Driver";

/**

* 获取数据库连接

* @return

* @throws Exception

public Connection getCon() throws Exception{

//通过java的反射机制进行加载

Class.forName(jdbcName);

Connection con=DriverManager.getConnection(dbUrl,dbUserName,dbPassword);

return con;

}

/**

* 关闭数据库连接，一定要关闭

* @param con

* @throws Exception

public void closeCon(Connection con) throws Exception{

if(con!=null){

con.close();

}

* 测试数据库连接

* @author qzp

public static void main(String[] args) {

DbUtil dbUtil=new DbUtil();

try {

dbUtil.getCon();

System.out.println("数据库连接成功");

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

(4)过滤器：由Filter负责，继承了Filter，实现了destroy()，doFilter和init方法，这里防止了用户非法登陆，(即不输入用户名，直接输入主界面的URL)，并且filter也要在web.xml中进行配置

public class LoginFilter implements Filter {

public void destroy() {

// TODO Auto-generated method stub

}

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,FilterChain filterChain) throws IOException, ServletException {

HttpServletRequest request=(HttpServletRequest)servletRequest;

HttpSession session=request.getSession();

Object o=session.getAttribute("currentUser");

if(o==null){

request.getRequestDispatcher("login.jsp").forward(servletRequest, servletResponse);

}else{

filterChain.doFilter(servletRequest, servletResponse);

}

public void init(FilterConfig arg0) throws ServletException {

// TODO Auto-generated method stub

}

(4)处理层：由servlet负责，继承httpservlet，实现doPost()和doGet()方法

public class LoginServlet extends HttpServlet{

DbUtil dbUtil=new DbUtil();

UserDao userDao=new UserDao();

@Override

protected void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {

this.doPost(request, response);

}

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

//从jsp页面获取来的

String userName=request.getParameter("userName");

String password=request.getParameter("password");

//良好的用户体验，不用每次输入错误，都要重新输入数据

request.setAttribute("userName", userName); request.setAttribute("password", password);

if(StringUtil.isEmpty(userName)||StringUtil.isEmpty(password)){

request.setAttribute("error", "用户名或密码为空！");

/*服务器端跳转(可以带信息，即传值带参数)，与重定向不一样，

*此处塞了error=用户名或者密码为空，可以一起传到err.jsp

request.getRequestDispatcher("err.jsp").forward(request, response);

return;

}

User user=new User(userName,password);

Connection con=null;

try {

con=dbUtil.getCon();

User currentUser=userDao.login(con, user);

if(currentUser==null){

request.setAttribute("error", "用户名或密码错误！");

//服务器端跳转，客户端跳转(重定向)无法带参数

request.getRequestDispatcher("err.jsp").forward(request, response);

}else{

// 获取Session，存在于服务器端，便于下面进行权限验证

HttpSession session=request.getSession();

session.setAttribute("currentUser", currentUser);

//客户端跳转重定向，不带参数

response.sendRedirect("main.jsp");

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally{

try {

dbUtil.closeCon(con);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

(5)显示层：由jsp页面负责

如：本案例中首先是一个登陆页面

<head>

<title>学生信息管理系统登录</title>

function resetValue() {

document.getElementById("userName").value = "";

document.getElementById("password").value = "";

}

</script>

</head>

<body>

<%--此处的action，应该与web.xml中servlet对应的url-pattern保持一致--%>

<table>

<tr><th>用户登陆系统</th></tr>

<tr>

<%--EL表达式 ${} 可以获取4大作用域(session,page..)的值 --%>

</tr>

<tr>

</tr>

<tr>

</tr>

<tr>

<%-- el表达式，可以获取request传入来的值--%>

<td><font color="red">${error}</font></td>

</table>

</form>

</body>

</html>

登陆成功跳转到success.jsp页面

<head>

<title>学生登陆系统主界面</title>

//权限验证:session的引入

if(session.getAttribute("currentUser")==null){

response.sendRedirect("index.jsp");

return;

}

</head>

<body>

success!当前登陆用户：${currentUser.userName}

</body>

登陆失败

<body>error！</body>

(6)非常重要的配置文件web.xml,它是web程序的人口处

<web-app version="2.5"

xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

<display-name>登陆系统</display-name>

<welcome-file-list>

<welcome-file>login.jsp</welcome-file>

</welcome-file-list>

<servlet-name>loginServlet</servlet-name>

<servlet-class>com.qzp.web.LoginServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>loginServlet</servlet-name>

<url-pattern>/login</url-pattern>

</servlet-mapping>

<filter-name>loginFilter</filter-name>

<filter-class>com.qzp.filter.LoginFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>loginFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

</web-app>

19. WebService

异构平台的交互，.net，php，java之间可以用各种语言来访问。

20.1 XML(DTD，Schema，Stax)

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。

20. Struts2

20.1 概述

Struts2本质是一个过滤器，过滤所有的请求，由StrutsPrepareAndExecuteFilter接管。

一个Strus2的完整流程，

1. login.jsp页面，用户输入用户名和密码，交由login.action来处理

<body>

username:<input type="text" name="username"><br>

password:<input type="password" name="password"><br>

</form>

</body>

2.配置web.xml，struts2本质是一个过滤器，它过滤了所有的请求，因而login.action也在其中

<filter-name>strust2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>strust2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

4. 到strust.xml中查找名字为login的action

<result name="success">/result.jsp</result>

</action>

</package>

</struts>

5. 建Loginaction类，通过set方法获取用户名和密码的值(strust2底层帮助完成)，最后还要执行execute()方法。

public class LoginAction {

private String username;

private String password;

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public String execute(){

return "success";

}

6. 返回结果集页面result.jsp

<body>

username:${requestScope.username }<br>

password:${requestScope.password }

</body>

Tips ：tld文档类型是定义的标签库语言;

dtd文档类型是定义了一套关于标记符的语法规则.

20.2 类型转换

默认的类型转化器：strutsTypeConverter

自定义类型转化器：

在action包的同一目录下配置一个.properties文件，这样就会在执行action前进行自定义类型转换。

三个主要信息：

(1)类型转换的配置文件(是一个键值对形式 key – value)

(2)类型转换的对象 – key

(3)处理类型转换的java文件 – value

20.3

21. Hibernate

1. what is O/R Mapping

Object/Relation Mapping 对象/关系映射

ORM 主要解决对象-关系的映射

ORM的思想：将关系数据库中表中的记录映射成为对象，以对象的形式展现，程序员可以把对数据库的操作转化为对对象的操作。

(1) JDBC操作数据库很繁琐

(2) Sql语句不是面向对象的

(3) O/R Mapping 简化编程

(4) O/R Mapping 跨越数据库平台

2. 二种配置方法

(1) Xml

(2) Annotation

4. hibernate的基础配置

22. 常用的快捷键

提示符:content assist-activation @ 通过设置来提示

Debug模式常用：

F6 下一步

F8 跳到下一个断点

F5 跳到方法内

更多相关推荐：

一周工作总结(范文-可参照模板): 一周工作总结一、工作的总体感受一周的工作总体感觉是很充实，每天都是那么忙碌，虽然总是重复做着同样的工作，但还是从这样不断重复的工作中明白了耐心、细心、克制情绪的重要。这是像我这种刚毕业的年轻人最缺少的东西，也是…
一周工作总结怎么写范文: 一周工作总结怎么写范文又是一周的工作结束了，这已经来上海的第四周的工作了.如果说第一周是适应工作，第二周便是熟悉，第三周是熟练，那么这一周便可以说对工作是渐入佳境了。经过一个月来对工作的摸索与实践，我已经对我工…
一周工作总结: 一、工作的总体感受一周的工作总体感觉还是很充实的，每天都是那么的忙碌，虽然总是做着同样的工作，但是这样不断的重复做同一件事情，从中还是可以得到锻炼，比如耐心，细心，控制自己的情绪，明白了这些东西，也是自己所得到…
一周工作总结范文: 一周工作总结范文一周工作总结一合理安排收支预算实现事业计划的重要保证单位预算是事业单位完成各项工作任务也是单位财务工作的基本依据因此认真做好我乡的收支预算具有十分重要的意义为搞好这项工作根据学校的发展实际既要总...
一周工作总结范文: 一周工作总结范文一周gt工作总结gt范文一这一周进行了八年级家长会在家长会上给与会的家长介绍了与孩子沟通的方法并对提高孩子学习效率给家长交流了六条建议由于我的讲话是对应邀而来的北京四中网校刘老师的补充所以对很多...
一周工作总结(范文-可参照模板): 一周工作总结一工作的总体感受一周的工作总体感觉是很充实每天都是那么忙碌虽然总是重复做着同样的工作但还是从这样不断重复的工作中明白了耐心细心克制情绪的重要这是像我这种刚毕业的年轻人最缺少的东西也是工作中最宝贵的东...
一周工作总结: 一、工作的总体感受一周的工作总体感觉是很充实，每天都是那么忙碌，虽然总是重复做着同样的工作，但还是从这样不断重复的工作中明白了耐心、细心、克制情绪的重要。这是像我这种刚毕业的年轻人最缺少的东西，也是工作中最宝贵…

政治理论学习总结范文: 政治理论学习总结范文以下是由本站推荐的政治理论学习总结一后勤系统的干部职工主要学习了xx关于社会主义荣辱观的重要讲话通过学习提高认识同志们认为xx的讲话对八荣八耻的概括精辟阐明了社会主义荣辱观的重要内容体现了爱...
一周工作总结范文: 一周工作总结范文总结一加强镇主要领导对办好本届科普宣传周给了大力支持按照区ampldquo两办amprdquo通知指定由分管书记镇长亲自负责镇科协等部门拿出具体5月10日方案经党委书记xx同志阅后并指定严格按照...
实习第一周心得总结-练森标: 第一周周工作总结时间一晃而过就在新的公司新的部门里待了一个星期首先得感谢万向马瑞利减震器的各位领导能给我展现自我才能的机会其次在督导师段玉蛟高工的帮助指导下使我了解了工艺部的具体工作流程及职能范围最后在公司同事...
党课学习总结范文: 党课学习总结范文本学期很荣幸能够参加学校的党课学习也很珍惜这次难得的学习机会在学习期间我始终坚持认真听课课堂上认真作笔记课后积极参与讨论在理论和实质上对党的认识有了很大的提高从党的性质到党的指导思想从党的根本宗...

大一上学期班长个人工作总结范文: 大一上学期班长个人工作总结范文大学的第一个学期过去了从担任班级联络员到班长的竞选再到现在的寒假似乎那一切只是昨天的事情担任班级班长让我学会处理很多事情但也曾碰到很多的困难虽然最后都慢慢的解决了一些可是仍然留有遗...

热门关注