注释嵌套注释_DIY注释

最新推荐文章于 2024-09-03 11:02:15 发布
最新推荐文章于 2024-09-03 11:02:15 发布
阅读量502 收藏
点赞数
文章标签： spring java linux mysql 编程语言
原文链接：https://www.javacodegeeks.com/2016/03/diy-annotations-3.html
版权

注释嵌套注释

从Java 5开始，Java中出现了注释。 我想做一个自己的注释，只是为了看看需要什么。 但是，我发现它们只是接口。

有擦

接口后面没有牙。 必须执行一些代码。 我认为这是橡胶行之有效的方法，我真的找到了解决方法。

首先，我需要一个目标

我选择了一个最近的热门话题：缓存。 我不想实现JSR 109（JCache），但也不想做典型的“ Hello World”。 我选择实现两个注释，一个注释不带任何参数，另一个注释不带参数。 我还需要一个缓存提供程序。 如果我要这样做的话，还可以将真正的缓存库加入其中。 它还遵循我的设计理念，即使用产品/库来达成目标，而不是将所有内容都进行家庭纺。 经过仔细考虑，我选择了hazelcast作为我的缓存引擎。 它是市场上最快的，而且是免费的。

更多决定

在选择了目标之后，我仍然需要找出如何在它们后面扎牙的方法。 经过一番挖掘，我发现了两种方法：

反射

几乎每次使用反射时，我都会为编写这么笨拙的代码感到遗憾。 另外，要按照我想要的方式进行操作，我必须创建自己的框架。 听起来两个注解的工作量很大。

面向方面的编程（AOP）

这非常适合我想做的事。 AOP致力于将样板代码减少到一个地方。 这将很方便并且与缓存紧密结合，因为缓存可分为以下步骤：

  1. 检查此情况是否之前已完成。
  2. 如果是这样的话：
    1. 检索存储的结果
  4. 如果不：
    1. 运行功能
    2. 存储结果
  6. 返回结果

也许这过于简单，但总的来说是正确的。 就像所有事物一样，细节决定成败。

同时，回到AOP牧场

虽然我知道AOP是适合我的地方，但我对此并不了解。 我发现Spring有一个AOP库，而众所周知的库是AspectJ。 AspectJ对我不熟悉，需要运行时引擎才能工作。 我对Spring更加熟悉，所以选择了它。 在研究Spring的AOP时，我发现我必须深入研究AspectJ的注释，因此无论如何我还是以某种形式或方式被AspectJ所困。

新概念，新词汇

编写方面不像编写对象。 它们是对象，但并非如此，因此当然需要一组新的术语。 我使用的是Spring AOP文档中的内容

我确实需要阅读几次该页面才能理解所讲的内容。 强烈建议您执行相同的操作，否则其余帖子听起来像胡言乱语。

切入点的构成和建议

切入点设计很容易，因为我只对带有注释的方法感兴趣。 它需要的建议是周围的建议，因为如果已经进行了匹配的调用，我就需要能够避免调用该方法。

最后的代码

Maven Pom.xml 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.darylmathison</groupId>
    <artifactId>annotation-implementation</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>4.2.4.RELEASE</spring.version>
    </properties>

    <description>
        This project is an example of how to implement an annotation via Spring AOP.
    </description>

    <scm>
        <url>https://github.com/darylmathison/annotation-implementation-example.git</url>
        <connection>scm:git:https://github.com/darylmathison/annotation-implementation-example.git</connection>
        <developerConnection>scm:git:git@github.com:darylmathison/annotation-implementation-example.git</developerConnection>
    </scm>

    <issueManagement>
        <system>GitHub</system>
        <url>https://github.com/darylmathison/annotation-implementation-example/issues</url>
    </issueManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</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-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.8</version>
        </dependency>

        <dependency>
            <groupId>com.hazelcast</groupId>
            <artifactId>hazelcast</artifactId>
            <version>3.6</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <reporting>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>2.7</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>dependencies</report>
                            <report>index</report>
                            <report>project-team</report>
                            <report>issue-tracking</report>
                            <report>scm</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-report-plugin</artifactId>
                <version>2.18.1</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>2.10.3</version>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>javadoc</report>
                            <report>test-javadoc</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jxr-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <linkJavadoc>true</linkJavadoc>
                </configuration>
                <reportSets>
                    <reportSet>
                        <reports>
                            <report>jxr</report>
                            <report>test-jxr</report>
                        </reports>
                    </reportSet>
                </reportSets>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-changelog-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <type>range</type>
                    <range>90</range>
                </configuration>
            </plugin>
        </plugins>
    </reporting>
</project>

注释

快取

缓存注释的可爱名称，对吗？ 

package com.darylmathison.ai.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by Daryl on 2/19/2016.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface CacheMe {
}
CacheMeNow 
package com.darylmathison.ai.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by Daryl on 2/19/2016.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface CacheMeNow {
    String key();
}

弹簧配置

我决定使用基于Java的配置，而不是像通常为了改变速度而使用的XML。 EnableAspectJAutoProxy批注是使Spring AOP开始工作的关键。 我一直在我旁边，直到我读到有关这颗小宝石的这篇文章。 有时，这是一天中最容易燃烧的事情。

AppConfig 

package com.darylmathison.ai.config;

import com.darylmathison.ai.cache.CacheAspect;
import com.darylmathison.ai.service.FibonacciService;
import com.darylmathison.ai.service.FibonacciServiceImpl;
import com.hazelcast.config.Config;
import com.hazelcast.config.EvictionPolicy;
import com.hazelcast.config.MapConfig;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by Daryl on 2/20/2016.
 */
@Configuration
@ComponentScan(basePackages = "com.darylmathison.ai")
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public Map<String, Object> cache() {
        Config config = new Config();
        MapConfig mapConfig = new MapConfig();
        mapConfig.setEvictionPercentage(50);
        mapConfig.setEvictionPolicy(EvictionPolicy.LFU);
        mapConfig.setTimeToLiveSeconds(300);
        Map<String, MapConfig> mapConfigMap = new HashMap<>();
        mapConfigMap.put("cache", mapConfig);
        config.setMapConfigs(mapConfigMap);

        HazelcastInstance instance = Hazelcast.newHazelcastInstance(config);
        return instance.getMap("cache");
    }

    @Bean
    public FibonacciService fibonacci() {
        return new FibonacciServiceImpl();
    }

    @Bean
    public CacheAspect cacheAspect() {
        return new CacheAspect();
    }
}

服务编号

基于经典Spring的设计需要服务吗？ 由于Spring使用代理来实现其AOP，因此强烈建议为带注释的类定义一个接口以实现。

斐波那契服务 

package com.darylmathison.ai.service;

/**
 * Created by Daryl on 2/20/2016.
 */
public interface FibonacciService {

    long calculate(int rounds);

    long calculateWithKey(int rounds);
}

FibonacciServiceImpl 

package com.darylmathison.ai.service;


import com.darylmathison.ai.annotation.CacheMe;
import com.darylmathison.ai.annotation.CacheMeNow;

/**
 * Created by Daryl on 2/20/2016.
 */
public class FibonacciServiceImpl implements FibonacciService {

    @Override
    @CacheMe
    public long calculate(int rounds) {
        return sharedCalculate(rounds);
    }

    @Override
    @CacheMeNow(key = "now")
    public long calculateWithKey(int rounds) {
        return sharedCalculate(rounds);
    }

    private static long sharedCalculate(int rounds) {
        long[] lastTwo = new long[] {1, 1};

        for(int i = 0; i < rounds; i++) {
            long last = lastTwo[1];
            lastTwo[1] = lastTwo[0] + lastTwo[1];
            lastTwo[0] = last;
        }

        return lastTwo[1];
    }
}

AOP的东西

这是注释实现的核心。 其他所有内容都可以用来支持后续的工作。

系统存档

根据Spring文档，集中化切入点定义是一个好主意。 

package com.darylmathison.ai.cache;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

/**
 * Created by Daryl on 2/20/2016.
 */
@Aspect
public class SystemArch {

    @Pointcut("@annotation(com.darylmathison.ai.annotation.CacheMe)")
    public void cacheMeCut() {

    }

    @Pointcut("@annotation(com.darylmathison.ai.annotation.CacheMeNow)")
    public void cacheMeNowCut() {

    }
}
缓存方面

周围注释使用切入点类的完整方法名称来定义建议的内容。 CacheMeNow批注的建议包括一个额外条件，因此可以定义批注，以便可以读取关键参数。 测试代码中揭示了CacheMeNow中的一个设计错误。 

package com.darylmathison.ai.cache;

import com.darylmathison.ai.annotation.CacheMeNow;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Map;

/**
 * Created by Daryl on 2/20/2016.
 */
@Aspect
public class CacheAspect {

    @Autowired
    private Map<String, Object> cache;

    @Around("com.darylmathison.ai.cache.SystemArch.cacheMeCut()")
    public Object simpleCache(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        StringBuffer keyBuffer = new StringBuffer();
        for(Object o: proceedingJoinPoint.getArgs()) {
            keyBuffer.append(o.hashCode());
        }
        String key = keyBuffer.toString();
        Object ret = cache.get(key);
        if(ret == null) {
            ret = proceedingJoinPoint.proceed();
            cache.put(key, ret);
        }
        return ret;
    }

    @Around("com.darylmathison.ai.cache.SystemArch.cacheMeNowCut() && @annotation(cacheMeNow)")
    public Object simpleCacheWithParam(ProceedingJoinPoint proceedingJoinPoint, CacheMeNow cacheMeNow) throws Throwable {
        Object ret = cache.get(cacheMeNow.key());
        if(ret == null) {
            ret = proceedingJoinPoint.proceed();
            cache.put(cacheMeNow.key(), ret);
        }
        return ret;
    }
}

测试代码

显示注释确实引起缓存的驱动程序代码。

斐波那契检验 

package com.darylmathison.ai.service;

import com.darylmathison.ai.config.AppConfig;
import org.junit.Assert;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by Daryl on 2/20/2016.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AppConfig.class})
public class FibonacciTest {

    private static final int ROUNDS = 12;
    private static final long ANSWER = 377;

    @Autowired
    private FibonacciService fibonacci;

    @org.junit.Test
    public void testCalculate() throws Exception {
        long start = System.currentTimeMillis();
        Assert.assertEquals(ANSWER, fibonacci.calculate(ROUNDS));
        long middle = System.currentTimeMillis();
        Assert.assertEquals(ANSWER, fibonacci.calculate(ROUNDS));
        long end = System.currentTimeMillis();
        Assert.assertTrue((end - middle) < (middle - start));
    }

    @org.junit.Test
    public void testCalculateWithKey() throws Exception {
        Assert.assertEquals(ANSWER, fibonacci.calculateWithKey(ROUNDS));
        // This test should not pass
        Assert.assertEquals(ANSWER, fibonacci.calculateWithKey(13));
    }
}

结论

注释不必很难实现。 使用AOP编程，我可以用很少的代码来实现两个注释。

翻译自: https://www.javacodegeeks.com/2016/03/diy-annotations-3.html

注释嵌套注释

dnc8371
关注
Java利用反射如何查找使用指定注解的类详解
08-29
主要给大家介绍了关于Java利用反射如何查找使用指定注解的类的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
多级嵌套选项卡_多级嵌套舌签Tabs
05-02
通常，这会涉及到使用条件注释、特性检测和对旧版浏览器的CSS hack等技术。 在代码中，`switch_tab.html`可能是包含整个选项卡系统的HTML文件，而`scripts`可能是一个JavaScript文件，其中包含了处理选项卡切换逻辑...
注释，无处不在的注释
最佳 Java 编程
05-25 217
十年前的2004年 ， Java 1.5开始提供注释。 很难想象没有此功能的代码。 实际上，首先引入了注释，以减轻开发人员编写繁琐的样板代码的痛苦，并使代码更具可读性。 考虑一下J2EE 1.4（没有可用的注释）和Java EE5。注释的采用通过消除所有配置XML大大简化了Java EE应用程序的开发。 即使在今天，更多的注释仍被添加到最新版本的Java EE中。 这样做的目的是减轻开发人员...
@PostConstruct、@DependsOn、@Order注解嵌套使用解决Bean加载优先级问题
最新发布
兴趣使然的草帽路飞
09-03 1万+
@PostConstruct、@DependsOn、@Order注解嵌套使用解决Bean加载优先级问题
注释嵌套注释_注释锤
cunfu6353的博客
07-08 393
注释嵌套注释 抽象 Java 5中的注释提供了非常强大的元数据机制。 但是，像其他任何东西一样，我们需要弄清楚在哪里使用它才有意义。 在本文中，我们将了解注释为何重要，并讨论使用和滥用案例。 表达元数据 让我们从我们熟悉的优秀Java程序员开始。 我们想表达一个类的实例可以被序列化。 我们可以通过实现Serializable接口来说明这一点，如下所示： public class...
注释与嵌套注释
Sampson__Lee的博客
11-23 5388
大家在写程序的时候是不是经常都会注释呢，反正我是有这么一个习惯，因为哪怕是自己写的程序，过个两三天自己看都得花一番功夫，所以注释是一个好习惯。     我们注释一般都是用 /*这是一个注释*/ 这种方法，而我在写通讯录的时候发现一个问题，就是如果想注释掉一段包含有其它注释的的代码，并不能达到自己的目的，如下图：     我在74行和97行添加的注释，但是真正注释掉的只有75行和76行，为什么呢
c语言注释的嵌套,C语言嵌套注释
zou_albert的博客
02-28 3453
主流的C/C++/Java/C#等语言，都将注释语法设计成不可嵌套的。 如: /* xxx /* yyy */ zzz */ 是非法的。 理由： 注释是用于写描述性语言的，嵌套会使得可读性更差。 但事实上，注释不只是用来写注释标注，还通常用于屏蔽代码块。需要注释掉一大段程序的时候，仍用这个注释符（ /* … * /）好不好呢？ 答案当然是：不好！！！ 如果那段要注释的程序中已经有地方用这个注释符注释过的话，那么再这样注释就可能会出问题。有些编译器在检测到"/*" 会寻找最近的" */"与其结合。 那么该如何
python绘图+注释_treePlotter_
10-01
"python绘图+注释_treePlotter_" 提示我们这里涉及到的是一个用于绘制树状图的工具或脚本，可能是作者自定义的一个函数或者库，用于帮助用户以图形方式表示数据结构，比如层次关系、分类或者决策树等。下面我们将...
html注释嵌套注释,如何嵌套HTML注释？
05-13
另一种方法是使用多个注释标记来模拟嵌套注释。例如： ```html <!-- 这是一个注释，包含一个嵌套的注释： --> <!-- 这是嵌套的注释 --> <!-- 这是包含嵌套注释的注释结束 --> ``` 但需要注意的是，这种方法可能会...
Lesson01_03 注释与特殊字符
10-31
-- 内部嵌套注释 --> 这是注释的其余部分 --> ``` 正确的做法是将它们拆分为两个独立的注释块。 #### 特殊字符 在HTML文档中，有些字符具有特殊的含义，如 `和 `>` 被用来定义HTML标签。为了在HTML文档中显示...
java 注释嵌套_作为Java程序员，你不能忽视的注释方式！
weixin_30234101的博客
02-16 1075
最近听到很多做程序员的小伙伴儿吐槽：从别人那儿接手的代码总是乱糟糟的，完全不知道写的什么！没有标记，没有说明，也没有一行注释，抓耳挠腮也看不懂！前程序员辞职留下的代码，谁也不愿意接手这个时候，就需要万能的“注释”大大了！所谓注释，便是用自然语言对源代码中某些语句或方法进行说明。并且，注释的内容不会被编译器编译。你可以在源代码中添加任何你想要添加的说明，随便多少都可以，只要你不觉得啰嗦。那么在Jav...
问题：注释嵌套
qijian111的专栏
06-30 653
/*/*/0*/**/1，注释不嵌套的编译器对此的解释是什么？
嵌套注释
07-31 892
例一：/*/**/"*/"/*"/**/在不允许嵌套注释的编译器中相当于 "*/"在允许嵌套注释的编译器中相当于 "/*"例二： /*/*/0*/**/1 在不允许嵌套注释的编译器中相当于 0*1 在允许嵌套注释的编译器中相当于 1来源：《C 陷阱与缺陷》
C++注释（嵌套）
qq_36689309的博客
07-13 2487
C++注释一般用 1. // 注释  ，这类注释为单行 //注释 啊2. /* 注释 */，多行注释/* 注释 */ 但这种方法不能嵌套，即不能使用如下写法/* 注释 /*注释*/ */因为对于/*而言，其后内容均为注释内容，直到遇见*/结束。3.嵌套注释可可利用条件编译指令实现，利于代码管理 #if  # elseif #endif由于以前的代码习惯十分差，因此最近也在学习如何更好的注释自己的...
行注释和块注释的嵌套关系
Benson的专栏
03-09 3326
public static void main(String[] args) { // // 单行注释嵌套 /* // 块注释里嵌套单行注释 */ // /* 单行注释里嵌套块注释 */ // 块注释里不能嵌套块注释 }
Html注释与Javascript注释的嵌套
cookieleehao的博客
01-19 3464
Html注释是&lt;!--      --&gt;，而JS的注释有两种，//    为单行，/* */为多行注释   而之前在阅读代码的时候遇到过以下的情况   &lt;script type="text/javascript"&gt; &lt;!-- functiondisplayMsg() {   alert("Hello World!") //--&gt; &lt;/s...
c语言中注释嵌套注释,C语言里面什么叫做嵌套注释
weixin_30431043的博客
05-19 1014
满意答案木鲁豫2013.09.23采纳率：47%等级：11已帮助：4766人C语言嵌套注释/*/**/对于一个允许嵌套注释的C编译器，无论上面的符号序列后面跟什么，都属于注释的一部分;而对于不允许嵌套注释的C编译器，后面跟的就是实实在在的代码内容。也许有人因此想到可以在后面再跟一个用一对引号引起的注释结束符:/*/**/ "*/"如果允许嵌套注释，上面的符号序列就等效于一个引号;如果不允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值