五J2EE模式2

前端控制器模式

前端控制器模式（Front Controller Pattern）是用来提供一个集中的请求处理机制，所有的请求都将由一个单一的处理程序处理。该处理程序可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。以下是这种设计模式的实体。

• 前端控制器（Front Controller） - 处理应用程序所有类型请求的单个处理程序，应用程序可以是基于 web 的应用程序，也可以是基于桌面的应用程序。
• 调度器（Dispatcher） - 前端控制器可能使用一个调度器对象来调度请求到相应的具体处理程序。
• 视图（View） - 视图是为请求而创建的对象。

实现

我们将创建 FrontController、Dispatcher 分别当作前端控制器和调度器。HomeView 和 StudentView 表示各种为前端控制器接收到的请求而创建的视图。

FrontControllerPatternDemo，我们的演示类使用 FrontController 来演示前端控制器设计模式。

步骤 1

创建视图。

HomeView.java

public class HomeView {

public void show(){ System.out.println("Displaying Home Page"); }

}

StudentView.java

public class StudentView { public void show(){ System.out.println("Displaying Student Page"); } }

步骤 2

创建调度器 Dispatcher。

Dispatcher.java

public class Dispatcher {

private StudentView studentView;

private HomeView homeView;

public Dispatcher(){

studentView = new StudentView();

homeView = new HomeView();

}

public void dispatch(String request){

if(request.equalsIgnoreCase("STUDENT")){ studentView.show(); }

else{ homeView.show(); }

}

}

步骤 3

创建前端控制器 FrontController。

FrontController.java

public class FrontController {

private Dispatcher dispatcher;

public FrontController(){

dispatcher = new Dispatcher();

}

private boolean isAuthenticUser(){

System.out.println("User is authenticated successfully.");

return true;

}

private void trackRequest(String request){

System.out.println("Page requested: " + request);

}

public void dispatchRequest(String request){

//记录每一个请求

trackRequest(request);

//对用户进行身份验证

if(isAuthenticUser()){ dispatcher.dispatch(request); }

}

}

步骤 4

使用 FrontController 来演示前端控制器设计模式。

FrontControllerPatternDemo.java

public class FrontControllerPatternDemo {

public static void main(String[] args) {

FrontController frontController = new FrontController();

frontController.dispatchRequest("HOME");

frontController.dispatchRequest("STUDENT");

}

}

步骤 5

执行程序，输出结果：

Page requested: HOME

User is authenticated successfully.

Displaying Home Page

Page requested: STUDENT

User is authenticated successfully.

Displaying Student Page

转载：https://www.runoob.com/design-pattern/front-controller-pattern.html

 

拦截过滤器模式

拦截过滤器模式（Intercepting Filter Pattern）用于对应用程序的请求或响应做一些预处理/后处理。定义过滤器，并在把请求传给实际目标应用程序之前应用在请求上。过滤器可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。以下是这种设计模式的实体。

• 过滤器（Filter） - 过滤器在请求处理程序执行请求之前或之后，执行某些任务。
• 过滤器链（Filter Chain） - 过滤器链带有多个过滤器，并在 Target 上按照定义的顺序执行这些过滤器。
• Target - Target 对象是请求处理程序。
• 过滤管理器（Filter Manager） - 过滤管理器管理过滤器和过滤器链。
• 客户端（Client） - Client 是向 Target 对象发送请求的对象。

实现

我们将创建 FilterChain、FilterManager、Target、Client 作为表示实体的各种对象。AuthenticationFilter 和 DebugFilter 表示实体过滤器。

InterceptingFilterDemo，我们的演示类使用 Client 来演示拦截过滤器设计模式。

步骤 1

创建过滤器接口 Filter。

Filter.java

public interface Filter { public void execute(String request); }

步骤 2

创建实体过滤器。

AuthenticationFilter.java

public class AuthenticationFilter implements Filter {

public void execute(String request){

System.out.println("Authenticating request: " + request);

}

}

DebugFilter.java

public class DebugFilter implements Filter {

public void execute(String request){

System.out.println("request log: " + request);

}

}

步骤 3

创建 Target。

Target.java

public class Target {

public void execute(String request){

System.out.println("Executing request: " + request);

}

}

步骤 4

创建过滤器链。

FilterChain.java

import java.util.ArrayList;

import java.util.List;

public class FilterChain {

private List<Filter> filters = new ArrayList<Filter>();

private Target target;

public void addFilter(Filter filter){

filters.add(filter);

}

public void execute(String request){

for (Filter filter : filters) {

filter.execute(request);

}

target.execute(request);

}

public void setTarget(Target target){ this.target = target; }

}

步骤 5

创建过滤管理器。

FilterManager.java

public class FilterManager {

FilterChain filterChain;

public FilterManager(Target target){

filterChain = new FilterChain();

filterChain.setTarget(target);

}

public void setFilter(Filter filter){ filterChain.addFilter(filter); }

public void filterRequest(String request){ filterChain.execute(request); }

}

步骤 6

创建客户端 Client。

Client.java

public class Client {

FilterManager filterManager;

public void setFilterManager(FilterManager filterManager){

this.filterManager = filterManager;

}

public void sendRequest(String request){

filterManager.filterRequest(request);

}

}

步骤 7

使用 Client 来演示拦截过滤器设计模式。

InterceptingFilterDemo.java

public class InterceptingFilterDemo {

public static void main(String[] args) {

FilterManager filterManager = new FilterManager(new Target());

filterManager.setFilter(new AuthenticationFilter());

filterManager.setFilter(new DebugFilter());

Client client = new Client();

client.setFilterManager(filterManager);

client.sendRequest("HOME");

}

}

步骤 8

执行程序，输出结果：

Authenticating request: HOME

request log: HOME

Executing request: HOME

转载：https://www.runoob.com/design-pattern/intercepting-filter-pattern.html

 

服务定位器模式

服务定位器模式（Service Locator Pattern）用在我们想使用 JNDI 查询定位各种服务的时候。考虑到为某个服务查找 JNDI 的代价很高，服务定位器模式充分利用了缓存技术。在首次请求某个服务时，服务定位器在 JNDI 中查找服务，并缓存该服务对象。当再次请求相同的服务时，服务定位器会在它的缓存中查找，这样可以在很大程度上提高应用程序的性能。以下是这种设计模式的实体。

• 服务（Service） - 实际处理请求的服务。对这种服务的引用可以在 JNDI 服务器中查找到。
• Context / 初始的 Context - JNDI Context 带有对要查找的服务的引用。
• 服务定位器（Service Locator） - 服务定位器是通过 JNDI 查找和缓存服务来获取服务的单点接触。
• 缓存（Cache） - 缓存存储服务的引用，以便复用它们。
• 客户端（Client） - Client 是通过 ServiceLocator 调用服务的对象。

实现

我们将创建 ServiceLocator、InitialContext、Cache、Service 作为表示实体的各种对象。Service1 和 Service2 表示实体服务。

ServiceLocatorPatternDemo，我们的演示类在这里是作为一个客户端，将使用 ServiceLocator 来演示服务定位器设计模式。

步骤 1

创建服务接口 Service。

Service.java

public interface Service { public String getName(); public void execute(); }

步骤 2

创建实体服务。

Service1.java

public class Service1 implements Service {

public void execute(){

System.out.println("Executing Service1");

}

@Override

public String getName() { return "Service1"; }

}

Service2.java

public class Service2 implements Service {

public void execute(){

System.out.println("Executing Service2");

}

@Override

public String getName() { return "Service2"; }

}

步骤 3

为 JNDI 查询创建 InitialContext。

InitialContext.java

public class InitialContext {

public Object lookup(String jndiName){

if(jndiName.equalsIgnoreCase("SERVICE1")){

System.out.println("Looking up and creating a new Service1 object");

return new Service1();

}

else if (jndiName.equalsIgnoreCase("SERVICE2")){

System.out.println("Looking up and creating a new Service2 object");

 return new Service2();

}

return null;

}

}

步骤 4

创建缓存 Cache。

Cache.java

import java.util.ArrayList;

import java.util.List;

public class Cache {

private List<Service> services;

public Cache(){

services = new ArrayList<Service>();

}

public Service getService(String serviceName){

for (Service service : services) {

if(service.getName().equalsIgnoreCase(serviceName)){

System.out.println("Returning cached "+serviceName+" object");

return service;

}

}

return null;

}

public void addService(Service newService){

boolean exists = false;

for (Service service : services) {

if(service.getName().equalsIgnoreCase(newService.getName())){

exists = true;

}

}

if(!exists){ services.add(newService); }

}

}

步骤 5

创建服务定位器。

ServiceLocator.java

public class ServiceLocator {

private static Cache cache;

static { cache = new Cache(); }

public static Service getService(String jndiName){

Service service = cache.getService(jndiName);

if(service != null){ return service; }

InitialContext context = new InitialContext();

Service service1 = (Service)context.lookup(jndiName);

cache.addService(service1);

return service1;

}

}

步骤 6

使用 ServiceLocator 来演示服务定位器设计模式。

ServiceLocatorPatternDemo.java

public class ServiceLocatorPatternDemo {

public static void main(String[] args) {

Service service = ServiceLocator.getService("Service1");

service.execute();

service = ServiceLocator.getService("Service2");

service.execute();

service = ServiceLocator.getService("Service1");

service.execute();

service = ServiceLocator.getService("Service2");

service.execute();

}

}

步骤 7

执行程序，输出结果：

Looking up and creating a new Service1 object

Executing Service1

Looking up and creating a new Service2 object

Executing Service2

Returning cached  Service1 object

Executing Service1

Returning cached  Service2 object

Executing Service2

转载：https://www.runoob.com/design-pattern/service-locator-pattern.html

 

传输对象模式

传输对象模式（Transfer Object Pattern）用于从客户端向服务器一次性传递带有多个属性的数据。传输对象也被称为数值对象。传输对象是一个具有 getter/setter 方法的简单的 POJO 类，它是可序列化的，所以它可以通过网络传输。它没有任何的行为。服务器端的业务类通常从数据库读取数据，然后填充 POJO，并把它发送到客户端或按值传递它。对于客户端，传输对象是只读的。客户端可以创建自己的传输对象，并把它传递给服务器，以便一次性更新数据库中的数值。以下是这种设计模式的实体。

• 业务对象（Business Object） - 为传输对象填充数据的业务服务。
• 传输对象（Transfer Object） - 简单的 POJO，只有设置/获取属性的方法。
• 客户端（Client） - 客户端可以发送请求或者发送传输对象到业务对象。

实现

我们将创建一个作为业务对象的 StudentBO 和作为传输对象的 StudentVO，它们都代表了我们的实体。

TransferObjectPatternDemo，我们的演示类在这里是作为一个客户端，将使用 StudentBO 和 Student 来演示传输对象设计模式。

步骤 1

创建传输对象。

StudentVO.java

public class StudentVO {

private String name;

private int rollNo;

StudentVO(String name, int rollNo){

this.name = name;

this.rollNo = rollNo;

}

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public int getRollNo() { return rollNo; }

public void setRollNo(int rollNo) { this.rollNo = rollNo; }

}

步骤 2

创建业务对象。

StudentBO.java

import java.util.ArrayList;

import java.util.List;

public class StudentBO {

//列表是当作一个数据库

List<StudentVO> students;

public StudentBO(){

students = new ArrayList<StudentVO>();

StudentVO student1 = new StudentVO("Robert",0);

StudentVO student2 = new StudentVO("John",1);

students.add(student1);

students.add(student2);

}

public void deleteStudent(StudentVO student) {

students.remove(student.getRollNo());

System.out.println("Student: Roll No " + student.getRollNo() +", deleted from database");

}

//从数据库中检索学生名单

public List<StudentVO> getAllStudents() { return students; }

public StudentVO getStudent(int rollNo) { return students.get(rollNo); }

public void updateStudent(StudentVO student) {

students.get(student.getRollNo()).setName(student.getName());

System.out.println("Student: Roll No " + student.getRollNo() +", updated in the database");

}

}

步骤 3

使用 StudentBO 来演示传输对象设计模式。

TransferObjectPatternDemo.java

public class TransferObjectPatternDemo {

public static void main(String[] args) {

StudentBO studentBusinessObject = new StudentBO();

//输出所有的学生

for (StudentVO student : studentBusinessObject.getAllStudents()) {

System.out.println("Student: [RollNo : " +student.getRollNo()+", Name : "+student.getName()+" ]");

}

//更新学生

StudentVO student =studentBusinessObject.getAllStudents().get(0);

student.setName("Michael");

studentBusinessObject.updateStudent(student);

//获取学生

studentBusinessObject.getStudent(0);

System.out.println("Student: [RollNo : " +student.getRollNo()+", Name : "+student.getName()+" ]");

}

}

步骤 4

执行程序，输出结果：

Student: [RollNo : 0, Name : Robert ]

Student: [RollNo : 1, Name : John ]

Student: Roll No 0, updated in the database

Student: [RollNo : 0, Name : Michael ]

转载：https://www.runoob.com/design-pattern/transfer-object-pattern.html