javaee_在JavaEE中使用CDI的简单面向方面的编程（AOP）

最新推荐文章于 2024-08-19 11:07:49 发布
最新推荐文章于 2024-08-19 11:07:49 发布
阅读量195 收藏
点赞数
文章标签： java spring servlet jsp aop
原文链接：https://www.javacodegeeks.com/2014/09/simple-aspect-oriented-programming-aop-using-cdi-in-javaee.html
版权
javaee

javaee

我们编写满足特定业务逻辑的服务API。 涵盖所有服务API(如安全性，日志记录，审核，度量延迟等)的跨领域问题很少。 这是一个重复的非业务代码，可以在其他方法之间重用。 重用的一种方法是将这些重复代码移入其自己的方法，并在服务API中调用它们，例如： 

public class MyService{
   public ServiceModel service1(){
      isAuthorized();
      //execute business logic.
   }
}

public class MyAnotherService{
  public ServiceModel service1(){
    isAuthorized():
    //execute business logic. 
  }
}

上面的方法会起作用，但不会在不产生代码噪音的情况下起作用，将横切关注点与业务逻辑混合在一起。 有另一种方法可以通过使用Aspect来解决上述要求，这种方法称为面向方面的编程(AOP)。 可以使用AOP的不同方式-通过使用Spring AOP，JavaEE AOP。 在此示例中，我将尝试在Java EE应用程序中使用使用CDI的AOP。 为了解释这一点，我选择了一个非常简单的示例，该示例构建一个Web应用程序以从Database中获取少量记录并显示在浏览器中。

创建数据访问层

表结构为： 

create table people(
    id INT NOT NULL AUTO_INCREMENT, 
    name varchar(100) NOT NULL,
    place varchar(100),
    primary key(id));

让我们创建一个Model类来保存个人信息

package demo.model;
public class Person{
  private String id;
  private String name;
  private String place;
  public String getId(){ return id; } 
  public String setId(String id) { this.id = id;}
  public String getName(){ return name; } 
  public String setName(String name) { this.name = name;}
  public String getPlace(){ return place; } 
  public String setPlace(String place) { this.place = place;}
}

让我们创建一个公开两种方法的数据访问对象–

  1. 获取所有人的细节
  2. 获取给定ID的一个人的详细信息
package demo.dao;

import demo.common.DatabaseConnectionManager;
import demo.model.Person;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

public class PeopleDAO {

    public List<Person> getAllPeople() throws SQLException {
        String SQL = "SELECT * FROM people";
        Connection conn = DatabaseConnectionManager.getConnection();
        List<Person> people = new ArrayList<>();
        try (Statement statement = conn.createStatement();
                ResultSet rs = statement.executeQuery(SQL)) {
            while (rs.next()) {
                Person person = new Person();
                person.setId(rs.getString("id"));
                person.setName(rs.getString("name"));
                person.setPlace(rs.getString("place"));
                people.add(person);
            }
        }
        return people;
    }

    public Person getPerson(String id) throws SQLException {
        String SQL = "SELECT * FROM people WHERE id = ?";
        Connection conn = DatabaseConnectionManager.getConnection();
        try (PreparedStatement ps = conn.prepareStatement(SQL)) {
            ps.setString(1, id);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) {
                    Person person = new Person();
                    person.setId(rs.getString("id"));
                    person.setName(rs.getString("name"));
                    person.setPlace(rs.getString("place"));
                    return person;
                }
            }
        }

        return null;
    }
}

您可以使用自己的方法来获取新的连接。 在上面的代码中，我创建了一个静态实用程序，该实用程序返回了相同的连接。

创建拦截器

创建拦截器涉及2个步骤：

  1. 创建Interceptor绑定，该绑定创建带有@InterceptorBinding注释的注释，该注释用于绑定拦截器代码和需要拦截的目标代码。
  2. 创建一个用@Interceptor注释的类，其中包含拦截器代码。 它包含用@AroundInvoke注释的方法，不同的生命周期注释， @AroundTimeout等。

让我们通过名称@LatencyLogger创建一个拦截器绑定

package demo;

import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.*;
import static java.lang.annotation.ElementType.*;
import javax.interceptor.InterceptorBinding;

@InterceptorBinding
@Retention(RUNTIME)
@Target({METHOD, TYPE})
public @interface LatencyLogger {
    
}

现在我们需要创建Interceptor代码，该代码以@Interceptor注释，并以上面创建的Interceptor绑定进行注释，即@LatencyLogger ： 

package demo;
import java.io.Serializable;
import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;

@Interceptor
@LatencyLogger
public class LatencyLoggerInterceptor implements Serializable{
  
  @AroundInvoke
    public Object computeLatency(InvocationContext invocationCtx) throws Exception{
        long startTime = System.currentTimeMillis();
        //execute the intercepted method and store the return value
        Object returnValue = invocationCtx.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println("Latency of " + invocationCtx.getMethod().getName() +": " + (endTime-startTime)+"ms");
        return returnValue;
        
    }
}

上面的代码中有两个有趣的事情：

  1. 使用@AroundInvoke
  2. 传递给方法的InvocationContext类型的参数

@AroundInvoke将方法指定为拦截器方法。 一个Interceptor类只能有一个带有此注释的方法。 每当目标方法被拦截时，其上下文都会传递给拦截器。 使用InvocationContext可以获取方法的详细信息，并将参数传递给该方法。

我们需要在WEB-INF / beans.xml文件中声明以上拦截器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd"
       bean-discovery-mode="all">
    
    <interceptors>
        <class>demo.LatencyLoggerInterceptor</class>
    </interceptors>
</beans>

创建带有拦截器注释的服务API

我们已经创建了Interceptor绑定和被执行的拦截器。 现在让我们创建Service API，然后使用Interceptor绑定对其进行注释

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package demo.service;

import demo.LatencyLogger;
import demo.dao.PeopleDAO;
import demo.model.Person;
import java.sql.SQLException;
import java.util.List;
import javax.inject.Inject;

public class PeopleService {

  @Inject
  PeopleDAO peopleDAO;

  @LatencyLogger
  public List<Person> getAllPeople() throws SQLException {
    return peopleDAO.getAllPeople();
  }

  @LatencyLogger
  public Person getPerson(String id) throws SQLException {
    return peopleDAO.getPerson(id);
  }

}

我们已经使用Interceptor绑定@LatencyLogger注释了服务方法。 另一种方法是在类级别进行注释，然后将注释应用于类的所有方法。 还要注意的另一件事是@Inject批注，该批注注入实例，即将依赖项注入到类中。

接下来是连接Controller和View以显示数据。 控制器是servlet，视图是使用JSTL标记的纯JSP。 

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package demo;

import demo.model.Person;
import demo.service.PeopleService;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.inject.Inject;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name = "AOPDemo", urlPatterns = {"/AOPDemo"})
public class AOPDemoServlet extends HttpServlet {

  @Inject
  PeopleService peopleService;

  @Override
  public void doGet(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
    try {
      List<Person> people = peopleService.getAllPeople();
      Person person = peopleService.getPerson("2");
      request.setAttribute("people", people);
      request.setAttribute("person", person);
      getServletContext().getRequestDispatcher("/index.jsp").forward(request, response);
    } catch (SQLException ex) {
      Logger.getLogger(AOPDemoServlet.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
}

上面的servlet可在http：// localhost：8080 /获得。

/ AOPDemo。 它获取数据并重定向到视图以显示该数据。 请注意，该服务也已使用@Inject注释注入。 如果没有注入依赖项，而是使用new创建依赖项，则拦截器将无法工作。 这是我在构建此样本时意识到的重要一点。

呈现数据的JSP将是

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" 
           uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>AOP Demo</title>
  </head>
  <body>
    <h1>Hello World!</h1>
    <table>
      <tr>
        <th>Id</th>
        <th>Name</th>
        <th>Place</th>
      </tr>
      <c:forEach items="${requestScope.people}" var="person">
        <tr>
          <td><c:out value="${person.id}"/></td>
          <td><c:out value="${person.name}"/></td>
          <td><c:out value="${person.place}"/></td>
        </tr>
      </c:forEach>
    </table>
    <br/>
    Details for person with id=2
    <c:out value="Name ${person.name} from ${person.place}" />
  </body>
</html>

这样，您将可以使用拦截器构建一个非常简单的应用程序。 感谢您的阅读，并一直陪着我到此为止。 请分享您的查询/反馈作为评论。 并在您的朋友之间分享这篇文章！

翻译自: https://www.javacodegeeks.com/2014/09/simple-aspect-oriented-programming-aop-using-cdi-in-javaee.html

javaee

cunfen0516
关注
【Java 笔记】Java CDI 相关整理
cheshang4180的博客
08-08 727
文前说明 作为码农中的一员，需要不断的学习，我工作之余将一些分析总结和学习笔记写成博客与大家一起交流，也希望采用这种方式记录自己的学习之旅。 本文仅供学习交流使用，侵权必删。 不用于商业目的，转载请注明出处。 1. 简介 CDI（Contexts And Depe...
java ee cdi_教程– CDI简介– Java EE的上下文和依赖注入（JSR 299）
06-25 885
CDI最令人兴奋的功能之一是允许任何人编写对Java EE核心平台的强大扩展，甚至更改核心行为本身。 这些扩展可以在支持CDI的任何环境中完全移植。 本文概述了主要的CDI功能，探讨了示例Web应用程序，并概述了该框架的一些基本机制。 当前有三种CDI实现： JBoss Weld （参考实现）， Apache OpenWebBeans和Caucho CanDI 。 一些库已经提供了CDI扩...
在JavaEE中使用CDI的简单面向方面的编程（AOP）
最佳 Java 编程
05-24 266
我们编写满足特定业务逻辑的服务API。 涵盖所有服务API（如安全性，日志记录，审核，度量延迟等）的跨领域问题很少。 这是一个重复的非业务代码，可以在其他方法之间重用。 重用的一种方法是将这些重复的代码移入其自己的方法，并在服务API中调用它们，例如： public class MyService{ public ServiceModel service1(){ isAu...
拦截器Interceptor未生效解决方案
最新发布
weixin_46916862的博客
08-19 539
总结：在配置拦截器时，如果要实现WebMvcConfigurer接口，需注意代码中是否继承了WebMvcConfigurationSupport类，如有则会使WebMvcConfigurer的实现类无效。
关于Java EE中CDI的一些浅谈
Eason的博客
03-27 3183
博客背景 因为在公司产品中用到Java EE中的CDI，所以需要做一个探究，以满足业务需要，通过一段时间的学习，将一些基本用法讲出来， 希望与各位网友一起讨论 概述 定义：Contextual Dependency Injection，上下文依赖注入。 context，上下文，可以绑定生命周期，可以与有状态的组件交互。 DI，依赖注入，以类型安全的方式注入一个组件到应用中去，包括指定特...
Java EE CDI处理程序方法示例
最佳 Java 编程
05-15 338
这是CDI Disposer方法的教程。 在CDI中，由于Producer方法生成的对象随后可以注入到应用程序中，因此使用Disposer方法，以便在其工作完成时将其删除。 Disposer方法始终与Producer方法匹配。 Disposer方法的使用示例是应用程序使用与数据库的连接时。 由于必须在与数据库的接口完成后关闭连接，因此使用Disposer方法删除表示连接的对象。 在这...
JavaEE6 CDI规范的使用1
08-08
然而，Tomcat作为一个轻量级的应用服务器，通常并不包含CDI的实现，因此如果要在Tomcat中使用CDI，需要额外配置。 JSF（JavaServer Faces）在早期版本中已经引入了对管理bean的注解支持，但在JSF 2.0规范即将完成的...
javaee编程案例.zip
12-29
9. **Spring框架**：虽然Spring不是JavaEE的一部分，但它是JavaEE开发中广泛使用的轻量级框架，提供了AOP（面向切面编程）、IOC（控制反转）等特性，可以与JavaEE的其他组件无缝集成。 10. **MVC（Model-View-...
JavaEE编程技术
09-26
10. **Spring框架与Java EE**：Spring框架是Java开发中的另一个重要工具，它可以与Java EE协同工作，提供更灵活的配置和更多的功能，如AOP（面向切面编程）和IOC（Inversion of Control）容器。 学习Java EE编程...
javaee_web
09-27
8. **Spring Framework**：虽然不是JavaEE标准的一部分，但Spring广泛用于JavaEE应用中，提供了依赖注入、AOP（面向切面编程）和MVC框架等功能。 9. **Tomcat / Jetty**：这些都是流行的Java Web容器，它们实现了...
javaee阶段代码，练习使用Java学习资料&项目源码&教程等资源
06-28
9. **Spring框架**：虽然Spring不是JavaEE标准的一部分，但它在JavaEE开发中非常流行，提供了一个全面的开发框架，包括依赖注入、AOP（面向切面编程）、MVC、数据访问、事务管理等功能。 10. **Maven或Gradle**：这...
cdi java_CDI(JSR 299)介绍——JavaEE平台的上下文与依赖注入
weixin_39854070的博客
02-21 379
CDI中最使人愉快的功用是准许每一小我在JavaEE平台中编写丁壮夜的扩展年夜性功用,甚至于修改其焦点本人。这些扩展年夜性功用是可以完整移植就职何支持CDI的情形中。本文是对CDI供应的次要功用中止一个概述，并经由进程一个Web运用示例来引见框架的运起色制。今朝有三种完成CDI的体式格式: JBoss Weld(参考完成)、 Caucho CanDI和ApacheOpenWebBeans。已有几个...
教程：编写自己的CDI扩展
最佳 Java 编程
05-20 433
今天，我将向您展示如何编写CDI扩展。 CDI提供了一种扩展功能的简便方法，例如 添加自己的范围， 启用Java核心类进行扩展， 使用注释元数据进行扩充或修改， 以及更多。 在本教程中，我们将实现一个扩展，该扩展将从属性文件中注入属性，就像往常一样，我将在github [更新： sources @ github ]中提供源。 目标 提供扩展，使我们能够执行以下...
jee chapter25(CDI)
qq_36414969的博客
03-26 330
CDI是帮助将Java EE平台的web层和事务层组合在一起的几个Java EE特性之一。 官方文档地址：https://javaee.github.io/tutorial/toc.html 使用cdi它会自动的帮助你创建变量的实例： 如你在servlet中有一个变量message，若加上注解@inject它就会在servlet创建时自动的实例化，注入servlet中。 @Injec...
装饰者模式
赫家旺的博客
04-15 200
从毛胚房的装修说起 每个人拿到属于自己的毛胚房时都兴奋不已，左看看右量量，筹划着装修的桩桩件件，憧憬着未来的幸福家园。每个人都希望装修完全按照自己的设想走，无论风格还是造价预算。可是装修这个活并不好干，同样的毛胚房有很多种装修方案，装修过程中也不可避免发生计划不如变化快的情形，往往最终的效果和最初的设想并不一致，这就是生活的实际。 软件开发的某个阶段和装修房子像极了！系统的基本功能实现后（...
Java CDI
ii00的博客
03-29 1572
CDI（Contexts and Dependency Injection），即上下文依赖注入，它是众多JEE规范中的一个，从JEE6开始CDI正式成为JEE规范，但CDI相关的概念不是新的，依赖注入的概念已经存在了许多年，相关的流行框架包括Spring，Google Guice等。 CDI提供的最基本服务如下： 上下文：将有状态组件的生命周期和交互绑定到定义良好但可扩展的生命周期上下文的能力 依...
Java EE6 CDI，命名组件和限定符
最佳 Java 编程
05-07 177
Java EE6的最大承诺之一就是简化了依赖注入的使用。 他们做到了，使用CDI 。 CDI代表Java EE的上下文和依赖注入，它提供了一个基础集，用于在企业应用程序中应用依赖注入。 在CDI之前，EJB 3还引入了依赖注入，但这有点基础。 您可以将EJB（全状态或无状态）注入另一个EJB或Servlet（如果您的容器支持）。 当然，并不是每个应用程序都需要EJB的，这就是CDI如此受欢...
Java EE CDI Producer方法教程
最佳 Java 编程
05-14 285
这是CDI Producer方法的教程。 在CDI中，生产者方法生成一个可以注入的对象。 当我们要注入本身不是bean的对象，要注入的对象的具体类型在运行时可能有所不同，或者当对象需要一些bean构造函数不执行的自定义初始化时，可以使用生产者方法。 生产者方法允许我们将任何JDK类公开为bean，并为同一实现类定义具有不同范围或初始化的多个bean。 他们还让我们将运行时多态与CDI结合使用...
php cdi_教程– CDI扩展编程
07-05 255
在Enterprise Java的早期，创建了许多框架，每个框架都有非常明确的技术目标。 不幸的是，这些很快变得超载，并塞满了很多功能，无法满足每一个需求。 CDI专家组旨在通过严格关注依赖关系注入的核心问题并定义一个非常强大的扩展机制来在其之上实现附加功能，来避免CDI规范出现此问题。 CDI扩展机制Swift流行起来，并且已经有许多高质量的扩展可用。 该机制称为“便携式CDI扩展”，因...
JavaEE_API中文版文档发布 - 全新CHM格式
它定义了如何实现服务端的编程模型，包括网络通信、安全性、数据库访问、事务管理、组件模型等方面。Java EE API中文版的出现，极大地便利了中文用户阅读和理解这些复杂的API和规范。 该文档通常以chm（Compiled ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值