方法 标签

回顾

在前面，我们通过 redis 集成了 MyBatis 的二级缓存，440.MyBatis的二级缓存整合redis ，接下来，我们来分析一下 RedisCache 的源码。

源码分析

RedisCache 主要是通过实现 Cache 接口来做的。数据存储和获取主要是通过操作 jedis 来实现。

public final class RedisCache implements Cache {
    private final ReadWriteLock readWriteLock = new DummyReadWriteLock();
    private String id;
    private static JedisPool pool;

    public RedisCache(String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        } else {
            this.id = id;
            RedisConfig redisConfig = RedisConfigurationBuilder.getInstance().parseConfiguration();
            pool = new JedisPool(redisConfig, redisConfig.getHost(), redisConfig.getPort(), redisConfig.getConnectionTimeout(), redisConfig.getSoTimeout(), redisConfig.getPassword(), redisConfig.getDatabase(), redisConfig.getClientName());
        }
    }
}

Terwer...大约 2 分钟

Struts2的Action中自定义方法的输入校验

自定义方法的输入校验

对于通过 action 的 method 属性所指定的自定义方法 myExecute ，其对应的自定义输入校验方法名为 validateMyExecute 。（底层是通过反射调用的）

public void validateMyExecute() {
	System.out.println("validateMyExecute invoked");

	 this.addActionError("action error");
}

public String myExecute() throws Exception {
	System.out.println("myExecute invoked");
	return SUCCESS;
}

校验方法的执行顺序

当在 Action 中指定了自定义的 execute 方法时，首先会执行自定义的 execute 方法所对应的输入校验方法，然后再去执行 validate 方法，执行完毕之后如果出现了任何错误都不会再去执行自定义的 execute 方法，流程转向了 input 这个名字所对应的页面上。

public void validateMyExecute() {
	System.out.println("validateMyExecute invoked");

	 this.addActionError("action error");
}

@Override
public void validate() {
	System.out.println("validate invoked");

	// this.addActionError("action error");
}

@Override
public String execute() throws Exception {
	return SUCCESS;
}

public String myExecute() throws Exception {
	System.out.println("myExecute invoked");
	return SUCCESS;
}
// validateMyExecute invoked
// validate invoked

效果

Terwer...大约 2 分钟

Struts2输入校验剖析之编码方式校验

Struts2 提供了两种校验方式。

使用编码方式进行校验

新建 register.jsp 页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Register</title>
</head>
<body>
	<h2 style="color:blue;">用户注册</h2>

	<s:actionerror cssStyle="color:red;" />

	----------------------------------------------------------------------

	<%--
	<form action="register.action">
		username: <input type="text" name="username" size="20" /><br/>
		password: <input type="password" name="password" size="20" /><br/>
		repassword: <input type="password" name="repassword" size="20" /><br/>
		age: <input type="text" name="age" size="20" /><br/>
		birthday: <input type="text" name="birthday" size="20"/><br/>
		geaduation: <input type="text" name="graduation" size="20"/><br/>
	
		<input type="submit" value="submit"/>
	</form>
	 --%>

	<s:fielderror cssStyle="color:blue;"></s:fielderror>
	<s:form action="register" theme="simple">
		username:<s:textfield name="username" label="username"></s:textfield><br/>
		password: <s:password name="password" label="password"></s:password><br/>
		repassword: <s:password name="repassword" label="repassword"></s:password><br/>
		age: <s:textfield name="age" label="age"></s:textfield><br/>
		birthday: <s:textfield name="birthday" label="birthday"></s:textfield><br/>
		geaduation: <s:textfield name="graduation" label="graduation"></s:textfield><br/>
	
		<s:submit value="submit"></s:submit>
	</s:form>

	<%--
	<s:form action="register">
		<s:textfield name="username" label="username"></s:textfield>
		<s:password name="password" label="password"></s:password>
		<s:password name="repassword" label="repassword"></s:password>
		<s:textfield name="age" label="age"></s:textfield>
		<s:textfield name="birthday" label="birthday"></s:textfield>
		<s:textfield name="graduation" label="graduation"></s:textfield>
	
		<s:submit value="submit"></s:submit>
	</s:form>
	--%>
</body>
</html>

Terwer...大约 4 分钟

Struts2自定义方法最佳实践

自定义方法实现

在 struts.xml 配置 method ，并且在对应的 Action 实现对应方法即可。

struts.xml

<action name="login2" class="space.terwer.struts23.LoginAction2" method="myExecute">
	<result name="success">/result2.jsp</result>
</action>

Terwer...大约 1 分钟

LinkedList源代码深入剖析

集合框架中的接口

除了类集接口之外，类集也是用 Comparator ， Iterator 和 ListIterator 接口。
简单地说， Comparator 接口定义了两个对象如何比较；Iterator 和 ListIterator 接口枚举类集中的对象。
为了在他们的使用中提供最大的灵活性，类集接口允许对一些方法进行选择。可选择的方法使得使用者可以更改类集中的内容。支持这些方法额类集被称为可修改的（modifiable）。不允许修改其内容的类集被称为不可修改的（unmodifiable）。如果对一个不可修改发类集使用这些方法，将引发一个 UnsupportedOperationException 异常。 所有内置的类集都是可修改的 。
调用 add() 方法可以将对象加入类集，注意 add() 带一个 Object 类的参数。因为 Object 是所有类的超类，所以任何类型的对象都可以被存储在一个类集中。然而原始类型不行。例如，一个类集不能直接存储类型 int ，char ， double 等的值。如果想存储这些对象，也可以使用原始类型包装器。

可以调用 addAll() 方法将一个类集的全部内容增加到另一个类集中。
可以通过调用 remove() 方法将一个对象删除。为了删除一组对象，可以调用 removeAll() 方法。调用 retainAll() 方法可以将除了一组指定的元素之外的所有元素删除。为了清空类集，可以调用 clear() 方法。
通过调用 contains() 方法可以确定一个类集中是否包含了一个指定的对象。
为了确定一个类集是否包含了另一个类集的全部元素，可以调用 contsinsAll() 方法。
当一个类集是空的时候，可以通过调用 isEmpty() 方法来予以确定。
调用 size() 方法可以获得类集中当前元素的个数。
toArray() 方法返回一个数组，这个数组包含了存储在调用类集中的元素。通过再类集合数组之间提供一条路径，可以充分利用这两者的优点。
一个更加重要的方法是 iterator() ，该方法对类集返回一个迭代程序。当使用一个类集框架时，迭代程序对于成功的编程来说是至关重要的。
Collection ：集合层次中的根接口，JDK 没有提供这个接口的直接实现类。
Set ：不能包含重复的元素。SortedSet 是一个按照升序排列元素的 Set 。
List ：是一个有序的集合，可以包含重复的元素。提供了按照索引访问的方式。
Map ：包含了 key-value 对。Map 不能包含重复的 key 。SortedMap 是一个按照升序排列 key 的 Map 。

Terwer...大约 9 分钟

Java_SE_Lesson_2：多态与static和final关键字

多态：父类型的引用可以指向子类型的对象。
Parent p = new Child;当使用多态方式调用方法时，首先检查父类中是否有 sing 方法，如果没有则编译错误；如果有，再去调用子类的 sing 方法。
一共有两种类型的强制类型转换：

a)向上类型转换（upcast）：比如说将 Cat 类型转换为 Animal 类型，即将子类型转换为父类型。对于向上类型转换，不需要显式指定。

b)向下类型转换（downcast）：比如将 Animal 类型转换为 Cat 类型。即将父类型转换为子类型。对于向下类型转换，必须要显式指定（必须要使用强制类型转换）。
抽象类（abstract class）：使用了 abstract 关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，不能 new 出来一个抽象类的对象（实例）。
抽象方法（abstract method）：使用 abstract 关键字所修饰的方法叫做抽象方法。抽象方法需要定义在抽象类中。相对于抽象方法，之前所定义的方法叫做具体方法（有声明，有实现）。
如果一个类包含了抽象方法，那么这个类一定是抽象类。
如果某个类是抽象类，那么该类可以包含具体方法（有声明、有实现）。
如果一个类中包含了抽象方法，那么这个类一定要声明成 abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。
无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。
在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个 abstract class。
接口（interface）：接口的地位等同于 class，接口中的所有方法都是抽象方法。在声明接口中的方法时，可以使用 abstract 关键字，也可以不使用。通常情况下，都会省略掉 abstract 关键字。
可以将接口看作是特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，不能有具体方法）。

类可以实现接口。实现使用关键字 implements 表示，代表了某个类实现了某个接口。
一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是个抽象类，那么就无需实现接口中的方法了。
Java 是单继承的，也就是说某个类只能有唯一一个父类；一个类可以实现多个接口，多个接口之间使用逗号分隔。
多态：所谓多态，就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。
static 关键字：可以用于修饰属性，也可以用于修饰方法，还可以用于修饰类（后面的课程讲）
static 修饰属性：无论一个类生成了多少个对象，所有这些对象共同使用唯一一份静态的成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。如果一个成员变量是 static 的，那么我们可以通过类名.成员变量名的方式来使用它（推荐使用这种方式）。
static 修饰方法：static 修饰的方法叫做静态方法。对于静态方法来说，可以使用类名.方法名的方式来访问。
静态方法只能继承，不能重写（Override）。

参考 Oracle 官方文档：

https://docs.oracle.com/javase/tutorial/java/IandI/override.html
final 关键字：final 可以修饰属性、方法、类。
final 修饰类：当一个类被 final 所修饰时，表示该类是一个终态类，即不能被继承。
final 修饰方法：当一个方法被 final 所修饰时，表示该方法是一个终态方法，即不能被重写（Override）。
final 修饰属性：当一个属性被 final 所修饰时，表示该属性不能被改写。
当 final 修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化（比如说不能从 10 变为 20）；如果 final 修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。
对于 final 类型成员变量，一般来说有两种赋初值方式：

a)在声明 final 类型的成员变量时就赋上初值

b)在声明 final 类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋上初值。
static 代码块：静态代码块。静态代码块的作用也是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在类被加载的时候执行，而构造方法是在生成对象的时候执行；要想调用某个类来生成对象，首先需要将类加载到 Java 虚拟机上（JVM），然后由 JVM 加载这个类来生成对象。
类的静态代码块只会执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法，所以 new 一次就会调用构造方法一次。
如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的类的静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只会执行一次。
不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量。
总结：静态的只能访问静态的；非静态的可以访问一切。
不能在静态方法中使用 this 关键字。

Terwer...大约 7 分钟

Java_SE_Lesson_1：面向对象高级

注意：方法的返回值对重载没有任何影响。

类是一种抽象的概念，对象是类的一种具体表示形式，是具体的概念。先有类，然后由类来生成对象（Object）。对象又叫做实例（Instance）。
类由两大部分构成：属性以及方法。属性一般用名词来表示，方法一般用动词来表示。
如果一个 java 源文件中定义了多个类，那么这些类中最多只能有一个类是 public 的，换句话说，定义的多个类可以都不是 public 的。
在 Java 中进行方法的参数传递时，无论传递的是原生数据类型还是引用类型，参数传递方式统一是传值（pass by value）。 Java 中没有传引用（pass by reference）的概念。
方法重载（Overload）。

表示两个或多个方法名字相同，但方法参数不同。

方法参数不同有两层含义：

1）参数个数不同。

2）参数类型不同。
构造方法重载：只需看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么可以使用 this 的方式调用，this 括号中的参数表示目标构造方法的参数。this 必须要作为构造方法的第一条语句，换句话说，this 之前不能有任何可执行的代码。
继承（Inheritence）：Java 是单继承的，意味着一个类只能从

另一个类继承（被继承的类叫做父类【基类，base class】，继承的类叫做子类），Java 中的继承使用 extends 关键字。
当生成子类对象时，Java 默认首先调用父类的不带参数的构造方法，然后执行该构造方法，生成父类的对象。接下来，再去调用子类的构造方法，生成子类的对象。【要想生成子类的对象，首先需要生成父类的对象，没有父类对象就没有子类对象。比如说：没有父亲，就没有孩子】。
super 关键字：super 表示对父类对象的引用。
如果子类使用 super 显式调用父类的某个构造方法，那么在执行的时候就会寻找与 super 所对应的构造方法而不会再去寻找父类的不带参数的构造方法。与 this 一样，super 也必须要作为构造方法的第一条执行语句，前面不能有其他可执行语句。
关于继承的 3 点：

a)父类有的，子类也有

b)父类没有的，子类可以增加

c)父类有的，子类可以改变
关于继承的注意事项

a)构造方法不能被继承

b)方法和属性可以被继承

c)子类的构造方法隐式地调用父类的不带参数的构造方法

d)当父类没有不带参数的构造方法时，子类需要使用 super 来显式地调用父类的构造方法，super 指的是对父类的引用

e)super 关键字必须是构造方法中的第一行语句。
方法重写（Override）：又叫做覆写，子类与父类的方法返回类型一样、方法名称一样，参数一样，这样我们说子类与父类的方法构成了重写关系。
方法重写与方法重载之间的关系：重载发生在同一个类内部的两个或多个方法。重写发生在父类与子类之间。
当两个方法形成重写关系时，可以在子类方法中通过 super.run 形式调用父类的 run 方法，其中 super.run 不必放在第一行语句，因此此时父类对象已经构造完毕，先调用父类的 run 方法还是先调用子类的 run 方法是根据程序的逻辑决定的。
在定义一个类的时候，如果没有显式指定该类的父类，那么该类就会继承于 java.lang.Object 类（JDK 提供的一个类，Object 类是 Java 中所有类的直接或间接父类）。
多态（Polymorphism）：我们说子类就是父类（玫瑰是花，男人是人），因此多态的意思就是：父类型的引用可以指向子类的对象。

Terwer...大约 5 分钟

Java_SE_第九讲：面向对象之封装

面向对象程序设计的三大基本特征：继承（Inheritence）、封装（Encapsulation）、多态（Polymorphism）
封装：类包含了数据与方法，将数据与方法放在一个类中就构成了封装。
如何定义类？

 修饰符 class 类的名字{
   // 类的内容（包含了属性与方法）
 }

Terwer...大约 3 分钟

Java_8-LTS

Java 8 于 2014 年 3 月 18 日发布， [188] [189] 包含了一些原本被项目在 Java 7 却延迟的功能。[190]

Terwer...大约 6 分钟

JDK之JavaBean内省机制

JDK 规范目录

JavaBean 是一种特殊的 Java 类，主要用于传递数据信息，这种 Java 类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

一、JavaBean

JavaBean 命名规则

一个 JavaBean 类中的方法，去掉 set 或 get 前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。
getAge/setAge --> age
getTime/setTime --> time
如果去掉前缀，剩余部分的第二个字母为大写，则全部大写
getCPU --> getCPU

Terwer...大约 4 分钟

跳转到: