java:运用工厂模式+反射实现可插拔的程序

最新推荐文章于 2024-08-29 19:00:00 发布
最新推荐文章于 2024-08-29 19:00:00 发布
阅读量2.6k 收藏 3
点赞数
分类专栏： java web 文章标签： 工厂模式 反射 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/startupmount/article/details/12250489
版权

我所实现的功能是这样的：会有很多个精灵，这些精灵都需要相应的条件判断才能创建对应的精灵，如果直接用工厂模式创建的话，随着精灵数量的增多，会让工厂方法难以招架，于是我将其改为mvc模式来实现：

angelReflectConfig.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
isAllUsed:是否在web解锁和踩点解锁时都必须判断精灵
isOnlyWebUsed:是否只在web端解锁升级时使用该精灵
isOnlyCheckUsed:是否只在踩点解锁时使用该精灵
isLegal:使用逻辑判断是否创建该精灵
上面四中情况只需要写一种就可以了，如果写多个，会抛出异常终止服务器启动，如果设置的属性为false,则默认进入isLegal模式


id:精灵编号，必须唯一
 -->
<angels>
<angel isAllUsed="true"  id="18">
com.lifeix.angel.strategy.HappyBirthdayStrategy
</angel>
<angel isAllUsed="true"  id="1">
com.lifeix.angel.strategy.NewbieStrategy
</angel>
<angel isOnlyCheckUsed="true"  id="3">
com.lifeix.angel.strategy.AdventurerStrategy
</angel>
<angel isOnlyCheckUsed="true"  id="9">
com.lifeix.angel.strategy.CasanovaStrategy
</angel>
<angel isOnlyCheckUsed="true"  id="12">
com.lifeix.angel.strategy.OtakuStrategy
</angel>
<angel isOnlyCheckUsed="true"  id="26">
com.lifeix.angel.strategy.SuperCaptainStrategy
</angel>
<angel isLegal="true"  id="71">
com.lifeix.angel.strategy.AlmightyStrategy
</angel>
<angel isLegal="true"  id="74">
com.lifeix.angel.strategy.BigVegasStrategy
</angel>
<angel isLegal="true"  id="27">
com.lifeix.angel.strategy.BirdieKingStrategy
</angel>
<angel isLegal="true"  id="85">
com.lifeix.angel.strategy.CarFanStrategy
</angel>
<angel isLegal="true"  id="76">
com.lifeix.angel.strategy.DrunkardStrategy
</angel>
<angel isLegal="true"  id="73">
com.lifeix.angel.strategy.EnvironmentalistStrategy
</angel>
<angel isLegal="true"  id="29">
com.lifeix.angel.strategy.FashionInsiderStrategy
</angel>
<angel isLegal="true"  id="24">
com.lifeix.angel.strategy.FrequentFlierStrategy
</angel>
<angel isLegal="true"  id="82">
com.lifeix.angel.strategy.GameJunkieStrategy
</angel>
<angel isLegal="true"  id="83">
com.lifeix.angel.strategy.GoldenBachelorStrategy
</angel>
<angel isLegal="true"  id="31">
com.lifeix.angel.strategy.GourmetStrategy
</angel>
<angel isLegal="true"  id="79">
com.lifeix.angel.strategy.KnowNothingStrategy
</angel>
<angel isLegal="true"  id="19">
com.lifeix.angel.strategy.MidnightAngelStrategy
</angel>
<angel isLegal="true"  id="84">
com.lifeix.angel.strategy.MostFeminineStrategy
</angel>
<angel isLegal="true"  id="81">
com.lifeix.angel.strategy.MovieFanStrategy
</angel>
<angel isLegal="true"  id="87">
com.lifeix.angel.strategy.MusicFanStrategy
</angel>
<angel isLegal="true"  id="80">
com.lifeix.angel.strategy.OneNightStandStrategy
</angel>
<angel isLegal="true"  id="86">
com.lifeix.angel.strategy.PhotographerStrategy
</angel>
<angel isLegal="true"  id="88">
com.lifeix.angel.strategy.PinStrategy
</angel>
<angel isLegal="true"  id="77">
com.lifeix.angel.strategy.RoadBullyStrategy
</angel>
<angel isLegal="true"  id="17">
com.lifeix.angel.strategy.SexyFigureStrategy
</angel>
<angel isLegal="true"  id="75">
com.lifeix.angel.strategy.ShopaholicStrategy
</angel>
<angel isLegal="true"  id="16">
com.lifeix.angel.strategy.SingingStarStrategy
</angel>
<angel isLegal="true"  id="72">
com.lifeix.angel.strategy.SingleNobleStrategy
</angel>
<angel isLegal="true"  id="78">
com.lifeix.angel.strategy.SportsFanStrategy
</angel>
</angels>

CacheAngelConfigFromFactory.java文件

package com.lifeix.angel.angelreflect;


import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;


import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


import com.l99.dto.angel.Angel;
import com.lifeix.angel.bean.CheckinCondition;
import com.lifeix.angel.service.UserAngelService;
import com.lifeix.angel.strategy.BasicStrategy;




/**
 * @DESCRIPTION:
 **/
public class CacheAngelConfigFromFactory {

private static final Logger log = LoggerFactory.getLogger(CacheAngelConfigFromFactory.class);

public static final int ALLUSEDCACHE = 0;
public static final int ONLYWEBUSEDCAHCE=1;
public static final int ONLYCHECKUSEDCACHE=2;
public static final int LEGALCACHE=3;

//是否在web解锁和踩点解锁时都必须判断精灵
public static Map<Integer, String> allUsedCache = new HashMap<Integer, String>();
//是否只在web端解锁升级时使用该精灵
public static Map<Integer, String> onlyWebUsedCache = new HashMap<Integer, String>();
//是否只在踩点解锁时使用该精灵
public static Map<Integer, String> onlyCheckUsedCache = new HashMap<Integer, String> ();
//使用逻辑判断是否创建该精灵
public static Map<Integer, String> legalCache = new HashMap<Integer, String> ();

public static void initConfig() {
String filePath = System.getProperty("angelConfig");
if(null == filePath || "".equals(filePath)) {
log.info("配置文件的angelConfig元素不能为空,服务器被终止启动......................");
System.exit(0);
} else {
URL url = CacheAngelConfigFromFactory.class.getResource(filePath);
if(null == url || "".equals(url)) {
log.info("找不到配置文件【"+filePath+"】,服务器被终止启动......................");
System.exit(0);
} else {
File file = new File(url.getFile());
log.info("config path:" + file.getAbsolutePath());
parseFile(file);
}
}
}

private static void parseFile(File file) {
Document doc = null;
try {
doc = new SAXReader().read(file);
Element rootElement = doc.getRootElement();
Iterator it = rootElement.elementIterator("angel");
while(it.hasNext()) {
Element ele = (Element) it.next();
List<Attribute> attrs = ele.attributes();
if(attrs.size() > 2) {
log.info("元素【" + ele.getName() + "】的属性只能为两个");
System.exit(0);
break;
} else {
String text = ele.getTextTrim();
boolean flag = false;
int id = Integer.parseInt(ele.attribute("id").getText().trim());

if(allUsedCache.containsKey(id) || onlyWebUsedCache.containsKey(id) || 
onlyCheckUsedCache.containsKey(id) || legalCache.containsKey(id)) {
log.info("已经存在ID值【"+id+"】,服务器被终止启动......................");
System.exit(0);
}

for(Attribute attr : attrs) {
String name = attr.getName();
String value = attr.getValue();

if("isAllUsed".equals(name) && Boolean.parseBoolean(value)) {
allUsedCache.put(id, text);
flag = !flag;
} else if("isOnlyWebUsed".equals(name) && Boolean.parseBoolean(value)) {
onlyWebUsedCache.put(id, text);
flag = !flag;
} else if("isOnlyCheckUsed".equals(name) && Boolean.parseBoolean(value)) {
onlyCheckUsedCache.put(id, text);
flag = !flag;
} else if(!flag || "isLegal".equals(name)) {
legalCache.put(id, text);
} 
}
}
}
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} 
}

/**
* @description:创建精灵
* @return:void
* @param condition
* @param data
* @param flag
*/
public static void putAngel(CheckinCondition condition, Map<Long, BasicStrategy> data, int flag) {
if(flag == ALLUSEDCACHE) {
generateAngelEntity(condition, data, allUsedCache);
} else if(flag == ONLYWEBUSEDCAHCE) {
generateAngelEntity(condition, data, onlyWebUsedCache);
} else if(flag == ONLYCHECKUSEDCACHE) {
generateAngelEntity(condition, data, onlyCheckUsedCache);
} else if(flag == LEGALCACHE) {
generateAngelEntity(condition, data);
} else {
throw new IllegalArgumentException("invalid parameter.............");
}
}

private static void generateAngelEntity(CheckinCondition condition, Map<Long, BasicStrategy> data) {
if(legalCache.size() > 0) {
Angel angel = UserAngelService.getUserAngelByAngelId(condition.getAccountId(), condition.getAngelId());
String packagePath = legalCache.get(Integer.parseInt("" + condition.getAngelId()));
data.put(condition.getAngelId(),reflectAngelEntity(packagePath, condition, angel));
}
}

private static void generateAngelEntity(CheckinCondition condition, Map<Long, BasicStrategy> data, Map<Integer, String> cache) {
if(cache.size() > 0) {
for(Entry<Integer, String> entry : cache.entrySet()) {
CheckinCondition cc = getCondition(condition);
cc.setAngelId(entry.getKey());
Angel angel = UserAngelService.getUserAngelByAngelId(cc.getAccountId(), cc.getAngelId());
data.put(cc.getAngelId(),reflectAngelEntity(entry.getValue(), cc, angel));
}
}
}

/**
* @description: 反射精灵类
* @return:BasicStrategy
* @param packagePath
* @return
* @throws ClassNotFoundException 
* @throws InvocationTargetException 
* @throws IllegalAccessException 
* @throws InstantiationException 
* @throws IllegalArgumentException 
*/
private static BasicStrategy reflectAngelEntity (String packagePath, CheckinCondition cc, Angel angel) {
Class clazz = null;
try {
clazz = Class.forName(packagePath);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(null == clazz) {
throw new NullPointerException("包路径载入异常......" + packagePath);
}
Constructor<?>[] cons = clazz.getConstructors();
if(cons.length > 0) {
for(Constructor con : cons) {
if(con.getParameterTypes().length == 2) {
BasicStrategy bs = null;
try {
bs = (BasicStrategy) con.newInstance(cc, angel);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("invalid parameter.............");
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return bs;
}
}
}
throw new NullPointerException("生成精灵实体为空......" + angel.getMedalId());
}

/**
* @description: 复制一份，防止多线程共享同一个对象，造成数据混乱
* @author:fuqiangj
* @return:CheckinCondition
* @param condition
* @return
*/
public static CheckinCondition getCondition(CheckinCondition condition) {
CheckinCondition cc = new CheckinCondition();
cc.setAccountId(condition.getAccountId());
cc.setAngelId(condition.getAngelId());
cc.setBirthday(condition.getBirthday());
cc.setCatId(condition.getCatId());
cc.setCheckIn(condition.isCheckIn());
cc.setCreate(condition.isCreate());
cc.setGender(condition.getGender());
cc.setIpAddress(condition.getIpAddress());
cc.setLocalId(condition.getLocalId());
cc.setAddVillage(condition.isAddVillage());
return cc;
}
}

AngelStrategyFactory.java类

package com.lifeix.angel.factory;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;


import org.perf4j.StopWatch;
import org.perf4j.slf4j.Slf4JStopWatch;


import com.l99.dto.angel.Angel;
import com.lifeix.angel.angelreflect.CacheAngelConfigFromFactory;
import com.lifeix.angel.bean.AngelType;
import com.lifeix.angel.bean.CheckinCondition;
import com.lifeix.angel.service.UserAngelService;
import com.lifeix.angel.service.share.AngelServiceShare;


public class AngelStrategyFactory {

static final StopWatch STOP_WATCH = new Slf4JStopWatch();
/**
* 生成用户需要解锁或升级的精灵策略
* @param accountId
* @return
*/
public static List<BasicStrategy> generateStrategies(CheckinCondition condition){
//临时存放数据，防止重复添加精灵
Map<Long, BasicStrategy> data = new HashMap<Long, BasicStrategy>();

if (condition==null) {
throw new IllegalArgumentException("没有解锁条件，无法生成解锁策略...");
}


CacheAngelConfigFromFactory.putAngel(condition, data, CacheAngelConfigFromFactory.ALLUSEDCACHE);

if (!condition.isCheckIn()) {//web 端精灵策略
generateWebStrategies(condition, data);
}else {//踩点精灵策略
generateCheckInStrategies(condition,data);
}

List<BasicStrategy> strategies = new ArrayList<BasicStrategy>();
if(data.size() > 0) {
for(BasicStrategy entry : data.values()) {
strategies.add(entry);
}
data.clear();
}
return strategies;
}

/**
* 生成web端精灵策略
* @param accountId
* @param condition 
* @param strategies 
*/
private static void generateWebStrategies(CheckinCondition condition, Map<Long, BasicStrategy> data){
CacheAngelConfigFromFactory.putAngel(condition, data, CacheAngelConfigFromFactory.ONLYWEBUSEDCAHCE);
parseAngel(condition, data);
}

/**
* 生成踩点精灵策略
* 
* @param condition 
* @param strategies
*/
private static void generateCheckInStrategies(CheckinCondition condition, Map<Long, BasicStrategy> data){

CacheAngelConfigFromFactory.putAngel(condition, data, CacheAngelConfigFromFactory.ONLYCHECKUSEDCACHE);

Set<Angel> canUpdateAngels = AngelServiceShare.getCatAngelMap(condition.getCatId());
if(canUpdateAngels != null && canUpdateAngels.size() > 0) {
for(Angel angel : canUpdateAngels){
//找出指定类别的精灵
if(null != angel.getCategories() && angel.getCategories().contains(condition.getCatId())) {
CheckinCondition cc = CacheAngelConfigFromFactory.getCondition(condition);  //重新创建一个对象，防止多个精灵公用同一个对象引用
cc.setAngelId(angel.getMedalId());
parseAngel(cc, data);
}
}
}
}

private static void parseAngel(CheckinCondition condition, Map<Long, BasicStrategy> data) {
STOP_WATCH.start();
CacheAngelConfigFromFactory.putAngel(condition, data, CacheAngelConfigFromFactory.LEGALCACHE);
STOP_WATCH.stop("generate strategey ");
}


}

jiangfullll
关注
专栏目录
用Java SPI实现可插拔
tonyhuang_google_com的专栏
11-07 1万+
前言：  在软件系统的设计中，可插拔是一个重要特性。它意味着给系统添加新功能时候（或者将原来功能的实现替换成新的实现而保持功能不变），不改变系统已有功能。这样的可插拔的功能模块被称为插件。插件(plugin)的出现可以很好地支持系统的可扩展性(Extensibility). 一个扩展性好的系统意味着很容易替换或者增加某些功能。 本文的目的是使用JDK6(或以上)的SPI(Service Prov
JAVA面试、笔试题
weixin_45689111的博客
04-20 1万+
@[TOC]目录 JAVA面试、笔试题 @目录 一、 CoreJava部分 7 1. java中有哪些基本类型？ 7 2. java反射 7 3. 易错,理解题 7 4. Java有几种创建对象的方法? 8 java为什么能够跨平台运行？ 8 整型数据转换成字符串的方式？ 8 String是基本数据类型吗？我可不可以写个类继承于String？ 8 谈谈&和&&的区别？ 8 Switch语句里面的条件可不可以是byte、long、String？使用时候还应注意什么？ 8 short
插拔式java_Java Swing APIs可插拔式外观风格特性应用
weixin_28982089的博客
02-27 215
Java Swing APIs可插拔式外观风格特性应用以下文字资料是由(历史新知网www.lishixinzhi.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！Java Swing 应用编程接口提供了可插拔式外观风格(PLAF)的特性 它允许Swing 图形用户接口(GUI)小应用根据编程人员定制的外观风格设置来改变界面外观风格几乎所有现代用户接口框架都结合了视图和控制 无论它...
Java进阶：常常听到的热插拔插件功能原来这么简单
最新发布
55555的博客
08-29 1929
SPI是java提供的一直接口提供服务，或者说接口动态定制机制，之前我们介绍过java SPI实现接口扩展，而热插拔插件实际上也是基于SPI来实现的。SPI有3个核心步骤：（1）对接口类实现扩展的实现类（2）在资源目录中声明实现类路径（3）通过加载扩展的实现类，从而实现调用到这里我们针对java热插拔插件的实现就完成了，跟着操作下来你会发现神秘的热插拔功能或许没有那么难以实现。
java 可插拔注解_Java™ 教程（注解）
weixin_39960319的博客
02-16 163
注解注解(一种元数据形式)提供有关不属于程序本身的程序的数据，注解对它们注解的代码的操作没有直接影响。注解有许多用途，其中包括：编译器的信息 — 编译器可以使用注解来检测错误或抑制警告。编译时和部署时处理 — 软件工具可以处理注解信息以生成代码、XML文件等。运行时处理 — 可以在运行时检查某些注解。本课程介绍了可以使用注解的位置，以及如何应用注解，Java平台标准版(Java SE API)中提...
Java SPI 机制，「可插拔」的奥义所在
Cbuc丶的博客
01-09 530
大家好，我是小菜。 一个希望能够成为 吹着牛X谈架构 的男人！如果你也想成为我想成为的人，不然点个关注做个伴，让小菜不再孤单！ 本文主要介绍 SPI 机制 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 微信公众号已开启，菜农曰，没关注的同学们记得关注哦！ 我们上篇文章讲到了 Java 中 Agent 用法，不少小伙伴都觉得该方式比较偏门，平常开发不常用（几乎没用）。其实不然，不常用是跟项目挂钩，项目不常用不代表该方法机制不常用，因此很多时候我们学习不能坐井观天，认为项目中没用到就可以不学，跟着项目成长往
java 可插拔注解_注解（五）：类型注解和可插拔类型系统
weixin_30496435的博客
03-07 193
Java SE 8 发布之前，注解只能应用于声明。随着 Java SE 8 发布，注解可以被应用于任何类型使用。这意味着注解可以被用于任何使用类型的地方。类型在什么地方使用的几个例子是类实例创建表达式(new)、强制类型转换、implements 子句和 throws 子句。这种形式的注解称为类型注解，在注解基础中提供了几个例子。类型注解被创建来增强确保 Java 程序强类型检查的分析方法。Jav...
Java继承与多态：封装、动态链接和向上转型
6. **设计模式和反射机制**：多态性在设计模式中起着关键作用，比如工厂模式、策略模式等，它们通常利用多态来创建可插拔的组件。反射机制则允许我们在运行时检查类的信息（如方法、字段），甚至动态调用方法，这...
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
2021 Java面试题总结（更新中）
chenKKai的博客
10-06 679
1.SpringMVC的流程？ 用户发送请求至前端控制器DispatcherServiet； 前端控制器收到请求后，调用处理器映射器HandlerMapping，请求获取Handler； 处理器映射器根据请求URL找到具体的处理器Handler，生成处理器对象及处理器拦截器（如果有则生成），一并返回给前端控制器； 前端控制器调用处理器适配器HandlerAdapter，请求执行Handler； 处理器适配器经过适配调用具体处理器进行处理业务逻辑； 处理器执行完成返回ModelAndView；
Java高频面试题（四）
ditto77的博客
10-30 1178
Java高频面试题四六、 框架部分6.1、什么是框架?6.2 、MVC模式6.3、 MVC框架6.4、 简单讲一下struts2的执行流程？6.5、 Struts2中的拦截器，你都用它干什么？6.6 、SpringMVC的执行流程？2.2.6.1MVC的各个部分技术实现?6.7、 struts2和springMVC有什么不同？6.8、 Spring中的两大核心？6.8.1、Spring是什么？6....
java 可插拔注解_java注解详解
weixin_39722917的博客
02-16 413
java注解学习注解是元数据的一种形式,提供程序相关的数据,但不是程序本身的一部分,注解不会直接操作他们所标注的代码。注解有很多用途:编译器所需的信息,如编译器可以用注解来检测错误或禁止警告编译时或发布时处理,如软件工具可以处理注解信息来生成代码、xml文件等运行时处理,某些注解在运行时也可以检测到注解基本点注解的形式最简单的:1@Entity@符号后的信息对编译器表明这是一个注解。以下注解的名称...
java 可插拔注解_20200311 8. 注解和可插拔性
weixin_36331058的博客
02-13 720
8. 注解和可插拔性8.1 注解和可插拔性在 web 应用中，使用注解的类仅当它们位于 WEB-INF/classes 目录中，或它们被打包到位于应用的WEB-INF/lib 中的 jar 文件中时它们的注解才将被处理。Web 应用部署描述符的 web-app 元素包含一个新的 metadata-complete 属性。metadata-complete 属性定义了 web 描述符是否是完整的，或...
（4）Java SPI &ShardingSphere 实战可插拔细节
RichardGeek的博客
07-07 1146
Java SPI &ShardingSphere 实战可插拔细节
基于Java SPI机制实现可插拔的应用插件
zh19940106的博客
06-07 961
Java Service Provider Interface (SPI) 机制是 Java 提供的一种用于实现组件化、可插拔式架构的机制。通过 SPI，Java 应用程序可以在运行时动态地加载和实例化服务实现类，而无需在编译时将其硬编码到应用程序中。本文将介绍如何通过使用Java的Service Provider Interface (SPI) 机制实现可插拔的应用插件。
java 插拔,如何在Java中实现可插拔适配器设计模式
weixin_35203962的博客
02-18 676
I know how to implement basic Adapter design pattern and also knows how C# using delegation to implement Pluggable Adapter design. But I could not find anything implemented in Java. Would you mind poi...
java动态加载jar实现热拔插
weixin_42146996的博客
08-07 3428
这是一篇关于项目经验积累的文章，在实际的项目中我们常常会遇到很多的问题，可能有很多种不同的解决办法，但是将自己的解决办法通过文字的方式记录下来，不失为一种经验值积累的好方法，毕竟好记性不如烂笔头嘛，下面就开始我们的正题，go！！！ 这几天，非非做公司的项目，需要做如下的一个需求，对于我一个基本没有项目经验的实习生来说，这可把我给难住了，终于在我翻了几十篇博客后，给出了我的解决方法： 需求如下： 有这么一个需求，我们提供一个接口标准，写成了一个jar，这个标准给不同的厂商去实现，实现完了打成一个jar，.
javaSE_8系列博客——Java语言的特性（四）--注解--（4）-- 类型注解和可插拔类型系统
softwareCraftsman
05-19 1216
在Java SE 8发布之前，注解只能应用于声明。从Java SE 8版本开始，注解也可以应用于任何类型的使用。这意味着注解可以在您使用类型的任何位置使用。使用类型的几个示例是类实例创建表达式（new），casts，implements clauses和throws子句。这种注解形式称为类型注解，并在注解基础中提供了几个示例。 创建类型注解，以支持改进Java程序分析方式，确保更强大的类型检查。
模块的可插拔设计（策略模式）
dyt443733328的博客
04-13 1万+
业务背景：有一个套餐，里面有多个模快组成，现固定了4种套餐，套餐中的模快有重复，例如模快：A,B,C,D套餐：甲：A          乙：A,B          丙：A,C          丁：A,B,C,D现要求，使用者可以根据自己的需求制定专属套餐，而不是局限于在上述四个套餐中进行选择，这样，就需要我们做到套餐中模快的可插拔设计，动态的组合。看一下具体的uml设计图对每个模快，我们都要有...
课程答疑小程序完整版：SSM+Vue+Uniapp实现
Spring MVC是Spring的一个模块，是基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架。MyBatis是一个支持定制化SQL、存储过程以及高级映射的持久层框架。Java SSM框架是传统Java企业级应用开发中非常流行的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值