本文深入探讨Java8新特性，如Stream API、Lambda表达式、Optional类等，详解Spring框架核心概念，包括AOP、IOC、DI及事务管理，并覆盖Java集合、线程、泛型等关键技术。
目录
6.方法引用（Method References） 两个冒号（::）
8.try-with-resource （Closeable、AutoCloseable）// JDK1.7
1.spring yml定义属性,中${} https://www.jb51.net/article/185447.htm
4.BeanFactory 和 FactoryBean 和 ApplicationContext
5.@PostConstruct （BeanPostProcessor 和 BeanFactoryPostProcessor） servlet生命周期
7.@WebServlet // J2EE 非 Spring
・AspectJ （aspectjweaver-1.9.X.jar）
3.Springboot的log中，logging.file.name与logging.file
5.Spring Boot中，证书的【创建】以及【使用】 // https
// 坑 ！！！to be [.../jre/lib/ext/ ]
33.【Runnable、Callable】与【ThreadPoolExecutor、ScheduledThreadPoolExecutor】 与【ExcutorService】
38.通过匿名内部实现多线程， 比实现Runnable 和继承 Thread 会灵活一点,从传参等操作
40.java switch 不加 break 继续执行 下一个case(不用匹配条件)
41.Java StringBuffer 和 StringBuilder 类
43.@Interceptor 和 Spring的AOP 之间有什么关联
44.JavaEE中的beans.xml中，定义的 有什么用
====
■常用链接
・Linux
Unix_Linux_常用命令总结_sun0322-CSDN博客
・bat常用命令
https://blog.csdn.net/sxzlc/article/details/89295226
・软件开发中常用单词
https://blog.csdn.net/sxzlc/article/details/104872052
・命令行中使用java命令
命令行，使用java的java 命令，直接调用执行class文件_sun0322-CSDN博客_java 运行class文件
■Spring 官网---学习资料
===
■本地电脑各种已经安装程序的目录（私密）
https://blog.csdn.net/sxzlc/article/details/111071591
===
■java8
Java8新特性学习_001_（Lambda表达式，函数接口，方法引用，Stream类，Optional类）_sun0322-CSDN博客
1.List的stream基本操作
===
Java有关List的stream基本操作 - 努力做一个伪程序员 - 博客园
2.Lambda 表达式
====
Java8新特性学习_001_（Lambda表达式，函数式接口，方法引用，Stream类，Optional类）_sun0322-CSDN博客
语法：参数 -> 表达式或代码块
---
参数：(param1,param2,…)
・没有参数时：()
・只有1个参数时，可以省略()
Java8 Lambda表达式教程_io-CSDN博客_java lambda表达式
java8之lambda表达式_xiaoye的博客-CSDN博客_java8 lambda
(坑！！！)在Java8的foreach()中使用return/break/continue，不会跳出循环_scyxm0426的专栏-CSDN博客
3.java 8中的Duration类
Java计算时间差、日期差总结_sy793314598的博客-CSDN博客_java 计算时间差
在Java8的foreach()中使用return/break/continue，不会跳出循环_scyxm0426的专栏-CSDN博客
4.Stream API
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合_云深不知处-CSDN博客
---
---
forEach（Consumer）接口函数
---
----
Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
Java8 Stream 使用汇总_Mr.zhao-CSDN博客_java stream 汇总
5.Optional // Java 8
Java 8 Optional 良心指南，建议收藏 - 沉默王二 - 博客园
NullPointerException（NPE），尽管和它熟得就像一位老朋友，
知道它也是迫不得已——程序正在使用一个对象却发现这个对象的值为 null，
于是 Java 虚拟机就怒发冲冠地把它抛了出来当做替罪羊。
当然了，我们程序员是富有责任心的，不会坐视不管，
于是就有了大量的 null 值检查。尽管有时候这种检查完全没有必要，
但我们已经习惯了例行公事。
终于，Java 8 看不下去了，就引入了 Optional，
以便我们编写的代码不再那么刻薄呆板。---
#Optional类
在Java中，可能我们看过最多的异常就是java.lang.NullPointerException，
这是使用null引用去调用一个方法或者字段的结果。
Java 8中提供了java.util.Optional<T> 类，是一个容器类，
代表一个值存在或不存在，原来用 null 表示一个值不存在，
现在 Optional 可以更好的表达这个概念。
并且可以避免空指针异常。
Optional常用方法有以下这些：
Optional.of(T t) : 创建一个 Optional 实例
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
T get()：获取Optional中的值
isPresent() : 判断是否包含值
orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
--
---
6.方法引用（Method References） 两个冒号（::）
当lambda表达式只是调用了某个方法时，可以用方法引用代替Lambda
java8 方法引用详解_清风不灭的博客-CSDN博客_java8 方法引用
在我们使用Lambda表达式的时候，
"->"右边部分是要执行的代码，即要完成的功能，可以把这部分称作Lambda体。
有时候，当我们想要实现一个函数式接口的那个抽象方法，
但是已经有类实现了我们想要的功能，
这个时候我们就可以用方法引用来直接使用现有类的功能去实现。
表达式:
person -> person.getAge();
可以替换成
Person::getAge
表达式
() -> new HashMap<>();
可以替换成
HashMap::new7.函数式接口
例子1：
---
---
二、四大函数式接口--（位置：java.util.function）
Function——函数型接口（有输入、有返回）
Predicate——断定型接口（有输入，返回boolean）
Consumer——消费型接口（只有输入，无返回）
Supplier——供给型接口（无入参，只有返回值）java必备——四大函数式接口（必须掌握）_悦来阅美好_IT-CSDN博客_java四大函数接口
Supplier 英 [səˈplaɪə] n. 供应者；供应国；供应商 // Java 接口函数
Function
Predicate 英 [ˈprɛdɪˌkeɪt; ˈprɛdɪkɪt] adj. 谓语的 v. 断言；使…基于 // Java 接口函数
Consumer
类子2
---
---
普通使用
---
普通使用 ⇒ 匿名内部类 ，Lambda表达式
ーーー
8.try-with-resource （Closeable、AutoCloseable）// JDK1.7
JDK1.7之后有了try-with-resource处理机制。
首先被自动关闭的资源需要实现Closeable或者AutoCloseable接口
---
9.操作文件
java中，正则表达式的使用 （最普通使用，Group，贪婪模式）_sun0322-CSDN博客_java 正则表达式 贪婪模式
package com.sxz.test;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
public class TestFileOperate {
private static String BATH_PATH = "C:\\test\\";
private static String COLUMN_REGEX="<itemName>.*?</itemName>";
public static int count;
public static void main(String[] args) {
getFileNameAndPrintColumnName("test001");
}
public static void getFileNameAndPrintColumnName(String folderName){
File[] files = listFilesMatching(BATH_PATH + folderName, ".*\\.(txt|TXT)$");
List<File> listFile = Arrays.asList(files);
listFile.stream().forEach(readFileTxt -> process(readFileTxt));
}
private static File[] listFilesMatching(String path, String regex){
final Pattern p = Pattern.compile(regex);
return new File(path).listFiles(file -> p.matcher(file.getName()).matches());
}
private static void process(File readFileTxt){
System.out.println("---" + readFileTxt.getName() + "------START");
count = 0;
final Pattern ptn = Pattern.compile(COLUMN_REGEX);
try(Stream<String> lines = Files.lines(readFileTxt.toPath(),Charset.forName("UTF-8"))){
lines.forEach(line->{
Matcher match = ptn.matcher(line);
if(match.find()){
System.out.println(match.group());
count = count + 1;
}
});
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("---" + readFileTxt.getName() + " 项目数：" + count + "------END");
}
}10.java 1.8中的接口
JDK8新特性：接口的静态方法和默认方法_aty-CSDN博客_接口的静态方法
・1.8之前的接口
一.1.8之前的接口特性：
1.接口中的变量都是静态常量，必须显示初始化
2.接口中的所有方法默认都是public abstract，方法不能有方法体。
3.接口中没有构造方法，不可以被实例化，可以被实现
4.实现类必须实现接口的所有方法
5.实现类可以实现多个接口---
・ JDK8及以后，允许我们在接口中定义static方法和default方法。
public interface JDK8Interface {
// static修饰符定义静态方法
static void staticMethod() {
System.out.println("接口中的静态方法");
}
// default修饰符定义默认方法
default void defaultMethod() {
System.out.println("接口中的默认方法");
}
}
11.XXXX
XXX
12.XXXX
XXX
13.XXXX
XXX
14.XXXX
XXX
15.XXXX
XXX
■Eclipse
https://blog.csdn.net/sxzlc/category_743907.html
■Spring相关
1.spring yml定义属性,中${} https://www.jb51.net/article/185447.htm
2.Spring 常用标注
spring常用注解的作用_素素z的博客-CSDN博客_spring常用注解及作用
3. IOC、DI 、@DependsOn、 @Lazy
---
使用Spring @DependsOn控制bean加载顺序_neweastsun的专栏-CSDN博客_@dependson
4.BeanFactory 和 FactoryBean 和 ApplicationContext
BeanFactory （根容器）
这个其实是所有Spring Bean的容器根接口，给Spring 的容器定义一套规范，给IOC容器提供了一套完整的规范，比如我们常用到的getBean方法等
---
---
ApplicationContext（IOC 容器）
【web项目】
ApplicationContext ac1 = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc)
或者
ApplicationContext ac2 = WebApplicationContextUtils.getWebApplicationContext(ServletContext sc)
或者
直接＠autowired获取
【非WEB项目】
ApplicationContext ac = new FileSystemXmlApplicationContext( "applicationContext.xml" )
FactoryBean ，只是名字相近
＝＝＝
5.@PostConstruct （BeanPostProcessor 和 BeanFactoryPostProcessor） servlet生命周期
（应用范围，J2EE的Servlet中）
6.Servlet // J2EE 非 Spring
7.@WebServlet // J2EE 非 Spring
public @interface WebServlet {
8.@Filter // J2EE 非 Spring
9.@Transactional
事务四个特性(ACID）
原子性(Atomicity)
一致性(Consistency)
隔离性(Isolation)
持久性(Durability)===
@Transactional(propagation=PROPAGATION_REQUIRES_NEW)
PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW -- 新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER -- 以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED -- 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。 ===
透彻的掌握 Spring 中@transactional 的使用_M.King的博客-CSDN博客
===
SpringBoot Transactional 事务的使用 @Transactional(propagation = Propagation.REQUIRED)注解的使用_乐菜鸟的博客-CSDN博客
===
默认值
Spring事务管理中@Transactional的propagation参数 - 归零，路上 - 博客园
===
10.事物传播
11.事物隔离级别
12.@value ${} #{} 的含义
@Value ${XXXX}
@value #{XXX} // EL表达式 对象.属性（people.age）
Spring @Value 用法小结，#与$的区别 - LarryZeal - 博客园
13.AOP学习1
AOP （Aspect Orient Programming）, 面向切面编程（AOP 是一种编程思想）
AOP 领域中的特性术语：
-------------------
通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。
连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。
切点（PointCut）: 可以插入增强处理的连接点。
切面（Aspect）: 切面是通知和切点的结合。
引入（Introduction）：引入允许我们向现有的类添加新的方法或者属性。
织入（Weaving）: 将增强处理添加到目标对象中，并创建一个被增强的对象，这个过程就是织入。
-------------------
Spring AOP——Spring 中面向切面编程 - SharpCJ - 博客园
---
---
---
----
13.AOP学习2
・AspectJ （aspectjweaver-1.9.X.jar）
Java学习之「Spring + AspectJ 」_sun0322-CSDN博客
AspectJ是一个面向切面的框架，是目前最好用，最方便的AOP框架
关于AspectJ的理解，很重要的两点：
===
- AspectJ是一个代码生成工具（Code Generator）。
- AspectJ语法就是用来定义代码生成规则的语法。
AspectJ框架实现原理_zhao9tian的专栏-CSDN博客_aspectj原理
===
・通过注解声明切点表达式：@Pointcut
Spring AOP——Spring 中面向切面编程 - SharpCJ - 博客园
@Pointcut("execution(* com.sharpcj.aopdemo.test1.IBuy.buy(..))")
public void point(){}
@Before("point()")
@After("point()")
@Around("point()")
public void xxx(ProceedingJoinPoint pj)
对自定义标注，声明切点时的操作方法
@Aspect
@Order(0)
标注对象：类
@Pointcut("@annotation(xxx.xxx.XXX)")
public void xxxPointcut(){}
@Around("xxxPointcut()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
log.info("around startTime:{},endTime:{}" ,startTime, endTime);
return proceedingJoinPoint.proceed();
// return null;
}・@Before、@After、@Around 代码示例
spring @Before @Around的执行关系_Jc0803kevin的专栏-CSDN博客
@Around
如果不执行proceedingJoinPoint.proceed()方法，那么目标方法不会执行
待执行目标方法：
public void test(){
log.info("方法执行test- > " );
//return false;
}
@Aspect
@Component
@Slf4j
public class KevinAspect {
private long startTime;
private long endTime;
/**
* 声明一个切点
*/
//@Pointcut("execution(* geektime.spring.springbucks.repository..*(..))")
@Pointcut("execution(* geektime.spring.springbucks.service..*(..))")
private void kevin(){
log.info("Pointcut startTime:{},endTime:{}" ,startTime, endTime);
}
/**
* 程序执行之前
*/
@Before("kevin()")
public void before(){
this.startTime = System.currentTimeMillis();
log.info("before startTime:{},endTime:{}" ,startTime, endTime);
}
/**
* 程序执行之后
*/
@After("kevin()")
public void after(){
this.endTime = System.currentTimeMillis();
log.info("after startTime:{},endTime:{},程序执行时间->{}ms" ,startTime, endTime,endTime-startTime);
}
@Around("kevin()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
log.info("around startTime:{},endTime:{}" ,startTime, endTime);
return proceedingJoinPoint.proceed();
// return null;
}
}
13.AOP学习3
・AspectJ
AspectJ是一个面向切面的框架，是目前最好用，最方便的AOP框架
（@Aspect、@Pointcut、@Before、@After、@Around）
・Springboot与AspectJ // 使用到AOP时，非常有用的配置
AspectJ对应的POM
<artifactId>spring-boot-starter-aop</artifactId>
(例：aspectjweaver-1.9.X.jar)
●@Aspect @Order各个通知的执行顺序
---
@Aspect@Order各个通知的执行顺序_u014240299的专栏-CSDN博客_aspect 顺序
・aspect 由 pointcount 和 advice 组成
---
---
・使用 @Aspect 注解的类就是切面.
・织入（(Weaving)） advice 的目标对象. 目标对象也被称为 advised object.
===
advice 的类型
before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)
after return advice, 在一个 join point 正常返回后执行的 advice
after throwing advice, 当一个 join point 抛出异常后执行的 advice
after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice.
around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.
===
・advice 英[ədˈvaɪs] 劝告; 忠告; 建议; 意见; // AOP 中的术语
Spring AOP之坑：完全搞清楚advice的执行顺序_洛丹伦的夏天-CSDN博客_aop执行顺序
---
14.@Autowired
１．场景：使用 @Autowired 的时候，到底是写接口还是实现类？
答案：写的接口
・@Autowired，Spring 会按 byType 的方式寻找接口的实现类。多个时，使用 @Qualifier 注解。
@Autowired
@Qualifier("yourBeanId")
private YourBean bean;２．在SpringBoot开发中，当一个接口A有多个实现类时，spring会很智能的将bean注入到List<A>或Map<String,A>变量中。
@Autowired
Map<String, IPerson> personMaps;15.SXXX
aaa
16.@Validated //Spring 提供
package org.springframework.validation.annotation;
...
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Validated {
/**
* Specify one or more validation groups to apply to the validation step
* kicked off by this annotation.
* <p>JSR-303 defines validation groups as custom annotations which an application declares
* for the sole purpose of using them as type-safe group arguments, as implemented in
* {@link org.springframework.validation.beanvalidation.SpringValidatorAdapter}.
* <p>Other {@link org.springframework.validation.SmartValidator} implementations may
* support class arguments in other ways as well.
*/
Class<?>[] value() default {};
}---
@Valid // Java提供
package javax.validation;
。。。
@Target({ METHOD, FIELD, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
public @interface Valid {
}---
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.1.0.Final</version>
</dependency>@Valid 和 @Validated 区别
--
17.MessageSource // Spring
public static void main(String[] args) {
MessageSource resources = new ClassPathXmlApplicationContext("beans.xml");
// String message = resources.getMessage(key, args, "DefaultMessage", Locale.ENGLISH);
String message = resources.getMessage(key, args, Locale.ENGLISH);
System.out.println(message);
}
// Local local = LocalContextHolder.getLocal();
配置类中
===
@Bean
public ResourceBundleMessageSource messageSource（） {
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
messageSource.setBasename("messages");
messageSource.setDefaultEncoding("UTF-8");
return messageSource ;
}
如果配置， 上面的main方法中，不需要new，可以直接注入使用。
===
// MessageSource是一个接口
// ResourceBundleMessageSource是最常见的MessageSource实现，它解决来自不同语言环境的资源包的消息。18.SXXX
19.SXXX
20.SXXX
21.SXXX
aaa
■Spring Boot，Sprint Batch 学习
1.基础
Spring Boot，Sprint Batch 学习_sun0322-CSDN博客
2.Spring boot 之 HelloWorld
SpringBoot之HelloWorld_sun0322-CSDN博客
3.Springboot的log中，logging.file.name与logging.file
Springboot，log文件配置时，logging.file.name与logging.file_sun0322-CSDN博客
4.Springboot中的各种标注
Spring Boot常用注解（绝对经典）_GooReey的博客-CSDN博客_springboot常用注解
SpringBoot之常用注解 - Nihaorz - 博客园
5.Spring Boot中，证书的【创建】以及【使用】 // https
使用JDK中的 keytool【创建证书】・【查看】・【使用】_sun0322-CSDN博客
6.★★★ SpringBatch 基础 ★★★
批处理框架spring batch基础知识介绍_topEngineerray的博客-CSDN博客_springbatch
---
自分整理
https://blog.csdn.net/sxzlc/article/details/124183805
===
===
■其他1（Java）
1.SecureRandom生成随机数
SecureRandom random= SecureRandom.getInstance("SHA1PRNG");
//系统将确定环境中是否有所请求的算法实现，是否有多个，是否有首选实现。
SecureRandom生成随机数_林夕5464的博客-CSDN博客_securerandom生成随机数
2.SLF4J
・介绍
为什么使用 SLF4J 而不是 Log4J 来做 Java 日志 - OSCHINA - 中文开源技术交流社区
slf4j的简单用法以及与log4j的区别 - QiaoZhi - 博客园
・配置
spring boot slf4j日记记录配置详解_liuweixiao520的博客-CSDN博客_slf4j配置详解
logback-boot.xml
・↑spring-boot中的使用，可以读取yml文件中的内容
・pom中 aritfactId=【spring-boot-starter-web】中，
包含SLF4J对应的jar slf4j-api
3.Junit
Eclipse中 Junit 正常运行完了 可是方法覆盖率全红 解决办法 （附带②EclEmma插件安装方法④覆盖率抽出与合并）_sun0322-CSDN博客
4.String.format
// 定义的字符串中，含有 「%s」
JAVA字符串格式化-String.format()的使用_lonely_fireworks的专栏-CSDN博客_java string.format用法
5.regular-expression
java中，正则表达式的使用 （最普通使用，Group，贪婪模式）_sun0322-CSDN博客_java 正则表达式 贪婪模式
=====
使用JDK API 帮助文档，查看正则表达是的定义时，
在【java.util.regex.Pattern】中查看
※ 查看时，使用【 jdk1.8中文的API帮助文档】
Character classes
[abc] a, b, or c (simple class)
[^abc] Any character except a, b, or c (negation)
[a-zA-Z] a through z or A through Z, inclusive (range)
[a-d[m-p]] a through d, or m through p: [a-dm-p] (union)
[a-z&&[def]] d, e, or f (intersection)
[a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction)
[a-z&&[^m-p]] a through z, and not m through p: [a-lq-z](subtraction)
Predefined character classes
. Any character (may or may not match line terminators)
\d A digit: [0-9]
\D A non-digit: [^0-9]
\h A horizontal whitespace character: [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]
\H A non-horizontal whitespace character: [^\h]
\s A whitespace character: [ \t\n\x0B\f\r]
\S A non-whitespace character: [^\s]
\v A vertical whitespace character: [\n\x0B\f\r\x85\u2028\u2029]
\V A non-vertical whitespace character: [^\v]
\w A word character: [a-zA-Z_0-9]
\W A non-word character: [^\w]
=====
6.java编译原理
java的源文件编码问题 - circumnavigation - 博客园
7.java启动参数
Java启动参数(-, -X, -XX参数)详解_我是guyue，guyue就是我O(∩_∩)O-CSDN博客_java启动参数
java -help
java -X
java -XX:+PrintFlagsInitial・帮助文档英文
https://docs.oracle.com/javase/7/docs/technotes/tools/windows/java.html
・帮助文档日文
https://docs.oracle.com/javase/jp/8/docs/technotes/tools/unix/java.html
・堆内存设置
The Parallel Collector (oracle.com)
8.线程（Thread）中的join方法。
调用此方法后，并行执行，变为，串行执行。
Thread 的join方法解释_清新哥哥的博客-CSDN博客
---
Java学习之Thread之【Monitor】与【wait】与【notify】与【sleep】_sun0322-CSDN博客
9.import static
导入指定类的全部静态成员变量、方法的语法格式如下：
import static package.ClassName.*;10.random
Random rad=new Random();
// 意思是随机产生一个大于等于0小于100的数 ------即包含0不包含100
int value = rad.nextInt(100);11.DBUNIT
DBUnit使用介绍 - shawWey - 博客园 (cnblogs.com)
---
熟悉单元测试的开发人员都知道，在对数据库进行单元测试时候，通常采用的方案有运用模拟对象(mock objects)和stubs两种。通过隔离关联的数据库访问类，比如JDBC的相关操作类，来达到对数据库操作的模拟测试。然而某些特殊的系统，比如利 用了EJB的CMP(container-managed persistence)的系统，数据库的访问对象是在最底层而且很隐蔽的，那么这两种解决方案对这些系统就显得力不从心了。
DBUnit的设计理念就是在测试之前，备份数据库，然后给对象数据库植入我们需要的准备数据，最后，在测试完毕后，读入备份数据库，回溯到测试前的状态；而且又因为DBUnit是对JUnit的一种扩展，开发人员可以通过创建测试用例代码，在这些测试用例的生命周期内来对数据库的操作结果进行比较。
---
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.dbunit</groupId>
<artifactId>dbunit</artifactId>
<version>2.5.3</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.24</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>---
11.ClassLoader
String classPath = TestClassLoader.class.getClassLoader().getResource("").getPath();// 正常显示
---
---
---
// 坑 ！！！to be [.../jre/lib/ext/ ]
彻底搞懂Class.getResource和ClassLoader.getResource的区别和底层原理_zhangshk_的博客-CSDN博客
加载顺序
java中类的加载顺序介绍(ClassLoader)_eff666的博客-CSDN博客_java的类加载过程
---
//原理
加载顺序，从上到下！！！
---
正常情况，复制刚才的class，到ext目录下才会有这种效果。
坑！！！！！！（ JRE 坏了。。。） ⇒ 我什么都没干，新建一个java类执行，
×：输出的结果 是【 \jre\lib\ext】。。。。
〇：期待的结果 是 【当前class所在的目录】
---
---
12.GC Log 分析与设定
Java中的GC（垃圾回收）log_sun0322-CSDN博客
13.equals方法实现
---
14.navite
---
native是与C++联合开发的时候用的！使用native关键字说明这个方法是原生函数，
也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。
这些函数的实现体在DLL中，JDK的源代码中并不包含，你应该是看不到的。
对于不同的平台它们也是不同的。
这也是java的底层机制，
实际上java就是在不同的平台上调用不同的native方法实现对操作系统的访问的。16.集合类
Collection
-------
Collections in Java - javatpoint
---------------------------------
Set中，不允许有重复的数据，HashSet是无序的，LinkedHashSet可以保持顺序。
Vector是线程安全的（速度慢）
LinkedList，查询速度慢，增删速度快。
------------------------------
Map
多线程时使用
---
17.正在表达式
java中，正则表达式的使用 （最普通使用，Group，贪婪模式）_sun0322-CSDN博客_java 正则表达式 贪婪模式
ーーー
18.BigDecimal
一般来说，BigInteger用的不是很多，BigDecimal用的稍微多一点，
就比如说JDBC中，如果一个字段的数据库类型是Number，
那么，getObject().getClass()的结果是java.math.BigDecimal。----
---
方法描述
add(BigDecimal) BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal) BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal) BigDecimal对象中的值相除，然后返回这个对象。
toString() 将BigDecimal对象的数值转换成字符串。
doubleValue() 将BigDecimal对象中的值以双精度数返回。
floatValue() 将BigDecimal对象中的值以单精度数返回。
longValue() 将BigDecimal对象中的值以长整数返回。
intValue() 将BigDecimal对象中的值以整数返回。---
19.BigInteger
・BigInteger
BigInteger相比Integer的确可以用big来形容。
它是用于科学计算，Integer只能容纳一个int，
所以，最大值也就是2的31次访减去1，
十进制为2147483647。但是，如果需要计算更大的数，
31位显然是不够用的，那么，此时BigInteger就能满足我们的需求了。
BigInteger能够容纳的位数那可就大了，
上千位没有任何问题。
除了容量大之外，BigInteger还封装了一些常见的操作，
比如+-*/的基本操作，还有绝对值，相反数，最大公约数，是否是质数等等的运算。
・BigDecimal
BigDecimal的实现利用到了BigInteger，
所不同的是，BigDecimal加入了小数位的概念。
----
20.Comparable 和 Compartor
-----
首先都是接口
----
--
根据Java语言规范的定义，一个使用了该注释的接口类型声明将被视为一个函数式接口。从概念上讲，一个函数式接口有且只有一个抽象方法。由于默认方法已经有了实现，所以它们不是抽象方法。如果一个接口中声明的抽象方法是重写了超类Object类中任意一个public方法，那么这些抽象方法并不会算入接口的抽象方法数量中。因为任何接口的实现都会从其父类Object或其它地方获得这些方法的实现。
注意：函数式接口的实现可以由Lambda表达式、方法引用、构造器引用等方式实现。
如果一个类型使用了该注释，那么编译器将会生成一个错误信息，除非这个类型是一个接口类型，而不是一个注释类型、枚举或类。同时使用该注释的接口满足函数式接口的要求，即一个函数式接口有且只有一个抽象方法。
但是编译器会将所有定义为函数式接口（满足函数式接口要求）的接口视为函数式接口，而不管这个接口声明中是否使用了函数式接口的注释（即@FunctionalInterface）。
从中我们可以知道：
1.一个函数式接口有且只有一个抽象方法。
2.默认方法不是抽象方法，因为它们已经实现了。
3.重写了超类Object类中任意一个public方法的方法并不算接口中的抽象方法。
所以虽然Comparator接口中有两个抽象方法compare和equals，但equals并不算入接口中的抽象方法，所以Comparator接口还是满足函数式接口的要求，Comparator接口是一个函数式接口。
----
-----比较器 Comparator
-----
21.序列化与反序列化
---
---
----
22.synchronized
一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。
---
23.validation 族
需要引用额外的jar
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.1.0.Final</version>
</dependency>
====
| @AssertFalse | 带注解的元素必须为false，支持boolean/Boolean |
| @AssertTrue | 带注解的元素必须为true，支持boolean/Boolean |
| @DecimalMax | 带注解的元素必须是一个数字，其值必须小于等于指定的最大值 |
| @DecimalMin | 带注解的元素必须是一个数字，其值必须大于等于指定的最小值 |
| @Digits | 带注解的元素必须是一个可接受范围内的数字 |
| @Future | 带注解的元素必须是将来的某个时刻、日期或时间 |
| @Max | 带注解的元素必须是一个数字，其值必须小于等于指定的最大值 |
| @Min | 带注解的元素必须是一个数字，其值必须大于等于指定的最小值 |
| @NotNull | 带注解的元素不能是Null |
| @Null | 带注解的元素必须是Null |
| @Past | 带注解的元素必须是过去的某个时刻、日期或时间 |
| @Pattern | 带注解的元素必须符合指定的正则表达式 |
| @Size | 带注解的元素必须大于等于指定的最小值，小于等于指定的最大值 |
| 带注解的元素必须是格式良好的电子邮箱地址 | |
| @NotEmpty | 带注解的元素不能是空，String类型不能为null，Array、Map不能为空，切size/length大于0 |
| @NotBlank | 字符串不能为空、空字符串、全空格 |
| @URL | 字符串必须是一个URL |
24.Resource // JDK 自带
25.Object 类的 基本方法
26.枚举类型 Enum
使用之前
public class DayDemo {
public static final int MONDAY =1;
public static final int TUESDAY=2;
public static final int WEDNESDAY=3;
public static final int THURSDAY=4;
public static final int FRIDAY=5;
public static final int SATURDAY=6;
public static final int SUNDAY=7;
}
----
使用之后
private String desc;//文字描述
private Integer code; //对应的代码
private Day2(String desc，Integer code){
this.desc=desc;
this.code=code;
}
public enum Day2 {
MONDAY("星期一",1),
TUESDAY("星期二",2),
WEDNESDAY("星期三",3),
THURSDAY("星期四",4),
FRIDAY("星期五",5),
SATURDAY("星期六",6),
SUNDAY("星期日",7);//记住要用分号结束
private String desc;//文字描述
private Integer code; //对应的代码
/**
* 私有构造,防止被外部调用
* @param desc
*/
private Day2(String desc，Integer code){
this.desc=desc;
this.code=code;
}
/**
* 定义方法,返回描述,跟常规类的定义没区别
* @return
*/
public String getDesc(){
return desc;
}
/**
* 定义方法,返回代码,跟常规类的定义没区别
* @return
*/
public int getCode(){
return code;
}
public static void main(String[] args){
for (Day2 day:Day2.values()) {
System.out.println("name:"+day.name()+
",desc:"+day.getDesc());
}
}
---
name:MONDAY,desc:星期一
name:TUESDAY,desc:星期二
name:WEDNESDAY,desc:星期三
name:THURSDAY,desc:星期四
name:FRIDAY,desc:星期五
name:SATURDAY,desc:星期六
name:SUNDAY,desc:星期日
27.泛型 （Generic）
17.Generic 泛型
•常用的泛型标识:T、E、K、V
类名<具体数据类型> 对象名 = new 类名<>()；
1.7之后，不再推荐 【。。。new 类名<具体数据类型>()】这种写法
28.内部类
//students是个list
Collections.sort(students, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
if(num == 0) {
return s1.getName().compareTo(s2.getName());
}
return num;
}
});29.泛型类型限定
必须实现了，Comparable 接口
---
ーーー
---
@SuppressWarnings({"unchecked", "rawtypes"})
public static <T> void sort(List<T> list, Comparator<? super T> c) {
---
30.泛型 ? extends T 与 ? super T
? extends T 与 ? super T_bitcarmanlee的博客-CSDN博客
java的一个设计理念是，与泛型相关的异常最好是在编译期间就被发现，因此设计了extends与super这两种方式。
具体来说，List<? extends T>表示该集合中存在的都是类型T的子类，包括T自己。
而List<? super T>表示该集合中存的都是类型T的父类，包括T自己。
List<? extends T>如果去添加元素的时候，因为list中存放的其实是T的一种子类，如果我们去添加元素，其实不知道到底应该添加T的哪个子类，这个时候桥接方法在进行强转的时候会出错。但是如果是从集合中将元素取出来，我们可以知道取出来的元素肯定是T类型。所以? extends T这种方式可以取元素而不能添加，这个叫get原则。
List<? super T>因为存的都是类型T的父类，所以如果去添加T类或者T类子类的元素，肯定是可以的。但是如果将元素取出来，则不知道到底是什么类型，所以? super T可以添加元素但是没法取出来，这个叫put原则。
31.Lombok中的@Builder用法
详解Lombok中的@Builder用法 - Sharpest - 博客园 (cnblogs.com)
@Builder注释为你的类生成相对略微复杂的构建器API。@Builder可以让你以下面显示的那样调用你的代码，来初始化你的实例对象：
User user =
User.builder()
.username( "XXXX" )
.password( "XXXX" )
.build();---
@Builder
public class User {
private final Integer code = 200;
private String username;
private String password;
}
// 编译后：
public class User {
private String username;
private String password;
User(String username, String password) {
this.username = username; this.password = password;
}
public static User.UserBuilder builder() {
return new User.UserBuilder();
}
public static class UserBuilder {
private String username;
private String password;
UserBuilder() {}
public User.UserBuilder username(String username) {
this.username = username;
return this;
}
public User.UserBuilder password(String password) {
this.password = password;
return this;
}
public User build() {
return new User(this.username, this.password);
}
public String toString() {
return "User.UserBuilder(username=" + this.username + ", password=" + this.password + ")";
}
}
}32.Java的类，是如何被初始化的
Java类的初始化顺序_小猴子的博客-CSDN博客_类的初始化
---
对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器。
---
所以，使用类的静态方法，不会创建对象，也不用创建对象。
---
---
java类静态域、块，非静态域、块，构造函数的初始化顺序 _超哥Blog-CSDN博客
【结论：】静态代码块是在类加载时自动执行的，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。且执行顺序为静态代码块------非静态代码块----构造函数。
【扩展：】静态代码块 与 静态方法：
一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;
需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的.
两者的区别就是:静态代码块是自动执行的; 静态方法是被调用的时候才执行的.
---
静态块只会被初始化一次，
非静态块，没new一次，都会被初始化
---
33.【Runnable、Callable】与【ThreadPoolExecutor、ScheduledThreadPoolExecutor】 与【ExcutorService】
无论是Runnable接口的实现类还是Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行，
ThreadPoolExecutor或ScheduledThreadPoolExecutor都实现了 ExcutorService接口，
而因此 Callable需要和Executor框架中的ExcutorService结合使用
————————————————
Callable和Future，一个产生结果，一个拿到结果。
import java.util.concurrent.Callable;
public class CallableDemo implements Callable<Integer> {
private int sum;
@Override
public Integer call() throws Exception {
System.out.println("Callable子线程开始计算啦！");
Thread.sleep(2000);
for(int i=0 ;i<5000;i++){
sum=sum+i;
}
System.out.println("Callable子线程计算结束！");
return sum;
}
}
---
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableTest {
public static void main(String[] args) {
//创建线程池
ExecutorService es = Executors.newSingleThreadExecutor();
//创建Callable对象任务
CallableDemo calTask=new CallableDemo();
//提交任务并获取执行结果
Future<Integer> future =es.submit(calTask);
//关闭线程池
es.shutdown();
try {
Thread.sleep(2000);
System.out.println("主线程在执行其他任务");
if(future.get()!=null){
//输出获取到的结果
System.out.println("future.get()-->"+future.get());
}else{
//输出获取到的结果
System.out.println("future.get()未获取到结果");
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("主线程在执行完成");
}
}34.Java 23种设计模式
JAVA设计模式总结之23种设计模式 - pony1223 - 博客园 (cnblogs.com)
---
工作中使用到的单词（软件开发）_sun0322-CSDN博客
35.Map.Entry
Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value (我们总说键值对键值对, 每一个键值对也就是一个Entry)
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
//第三种：推荐，尤其是容量大时
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
}36.初始化对于类与接口的异同
---
JVM （四） 初始化对于类与接口的异同详细解释_但行好事 莫问前程-CSDN博客
---
37.线程内部类
public class Demo {
public static void main(String[] args) {
// 继承Thread类实现多线程
new Thread() {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--" + i);
}
}
}.start();
// 实现Runnable接口实现多线程
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--" + i);
}
}
}) {
}.start();
}
}
38.通过匿名内部实现多线程， 比实现Runnable 和继承 Thread 会灵活一点,从传参等操作
public String first(HttpServletRequest request,WeChatQRPO weChatQRPO){
String url = request.getSession().getServletContext()
.getRealPath("/upload/img");
String zipPath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath()+"/upload/img/zip/"+weChatQRPO.getShopName()+"/";//存储路径
new Thread(new Runnable() {
@Override
public void run() {
shopService.getFirst(url,zipPath,weChatQRPO,from,endPoint,accessKeyId,accessKeySecret,filePrefix,bucket,fileHeadUrl);
}
}).start();
return "true";
}
这样就可以启动一个线程帮我们做事…
这里注意:
启动一个线程之后,HttpServletRequest 对象的参数是传不过去的, 如果你需要HttpServletRequest 里边的参数的话,最好以其他形式传过去 比如:String
xxx
39.JAVA中float与double的区别
====
float是单精度类型,精度是8位有效数字，取值范围是10的-38次方到10的38次方，float占用4个字节的存储空间
double是双精度类型，精度是17位有效数字，取值范围是10的-308次方到10的308次方，double占用8个字节的存储空间
当你不声明的时候，默认小数都用double来表示，所以如果要用float的话，则应该在其后加上f
例如：float a=1.3;
则会提示不能将double转化成float 这成为窄型转化
如果要用float来修饰的话，则应该使用float a=1.3f
注意float是8位有效数字，第7位数字将会产生四舍五入
所以如果一个float变量 这样定义: float a=1.32344435; 则第7位将产生四舍五入(5及5以下的都将舍去)
====
40.java switch 不加 break 继续执行 下一个case(不用匹配条件)
====
原因：
在java Switch-Case 语句中一旦匹配case条件，就会顺序执行后面的程序代码，而不管后面的case是否匹配，直到遇见break或者switch结束。
xxx
41.Java StringBuffer 和 StringBuilder 类
Java StringBuffer 和 StringBuilder 类 | 菜鸟教程 (runoob.com)
构造
方法
append("xxx")
insert(index, "xxx")
delete(beginIndex, endIndex)
xxx
42.Javaee 中的 @Interceptor 注解
在Java Enterprise Edition（JavaEE）中，@Interceptor是用于创建拦截器的注解。拦截器是一种在方法调用之前或之后执行的组件，用于处理特定的业务逻辑或增强方法的行为。
要使用@Interceptor注解，需要执行以下步骤：
创建一个实现了javax.interceptor.Interceptor接口的拦截器类。该接口定义了拦截器的方法。
在拦截器类上使用@Interceptor注解，以标识该类是一个拦截器。
使用@Interceptor注解的value属性指定拦截器绑定到的目标类或方法。可以使用通配符(*)来匹配多个类或方法。
在拦截器类的方法上使用@AroundInvoke注解，以指定拦截器的处理逻辑。这个方法将在目标方法调用之前和之后执行。
以下是一个使用@Interceptor注解的示例：
import javax.interceptor.AroundInvoke;
import javax.interceptor.Interceptor;
import javax.interceptor.InvocationContext;
@Interceptor
public class LoggingInterceptor {
@AroundInvoke
public Object logMethod(InvocationContext context) throws Exception {
System.out.println("Entering method: " + context.getMethod().getName());
Object result = context.proceed(); // 调用目标方法
System.out.println("Exiting method: " + context.getMethod().getName());
return result;
}
}在上面的示例中，LoggingInterceptor类使用@Interceptor注解来标识它是一个拦截器。@AroundInvoke注解用于指定拦截器的处理逻辑，即在目标方法调用之前输出一个进入消息，并在调用之后输出一个退出消息。
要使用拦截器，需要在目标类或方法上使用@Interceptors注解来绑定拦截器。例如：
import javax.ejb.Stateless;
import javax.interceptor.Interceptors;
@Stateless
@Interceptors(LoggingInterceptor.class)
public class MyEJB {
// ...
}===
xxx
43.@Interceptor 和 Spring的AOP 之间有什么关联
@Interceptor和Spring的AOP（面向切面编程）有一些相似之处，也有一些区别。
相似之处：
- 目的：@Interceptor和Spring AOP都用于在方法调用之前或之后执行额外的逻辑，例如日志记录、性能监控、事务管理等。
- 代理机制：@Interceptor和Spring AOP都使用代理机制来实现拦截器的功能。拦截器可以在目标方法前后插入额外的逻辑，而对于目标对象的调用则由代理对象来处理。
区别：
- 引用：@Interceptor是JavaEE的标准规范，而Spring AOP是Spring框架的一部分。@Interceptor可以在任何支持JavaEE规范的容器中使用，而Spring AOP仅限于Spring框架中。
- 注解方式：@Interceptor使用注解来标识和配置拦截器，而Spring AOP主要使用切点表达式和通知（Advice）来定义拦截点和拦截逻辑。
- 功能：Spring AOP比@Interceptor更强大，提供了更多的功能和灵活性。Spring AOP支持基于切点表达式的细粒度拦截，如在特定方法、类、包或注解上定义拦截；同时支持多种类型的通知，包括前置通知、后置通知、异常通知和环绕通知等。
- 环境：@Interceptor适用于JavaEE环境，如EJB（Enterprise JavaBeans）中进行拦截。而Spring AOP适用于Spring框架的应用程序，可以与Spring容器集成并利用Spring的依赖注入和事务管理等功能。
尽管存在一些区别，但@Interceptor和Spring AOP都提供了一种简洁和可重用的方式来管理横切关注点，从而降低了代码的复杂性，提高了代码的可维护性。选择使用哪种方式取决于应用程序的需求和环境。
44.JavaEE中的beans.xml中，定义的 <Interceptors>有什么用
JavaEE中的beans.xml中，定义的 <Interceptors>有什么用
元素用于在JavaEE中定义拦截器。拦截器可以用于在EJB、CDI、JAX-RS和JAX-WS应用程序中截获和处理方法调用。它们可以被用来实现日志记录、安全检查、性能监控等功能。
在元素中，可以定义一个或多个子元素，每个子元素表示一个拦截器的配置。
一个子元素可以包含以下元素：
：指定拦截器类的全限定名。
：指定在方法调用前后执行的拦截方法。
：指定不需要拦截的类或接口。
：指定不需要拦截的类或接口的正则表达式。
下面是一个 beans.xml 文件的例子，定义了一个名为 MyInterceptor 的拦截器：
<?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_2.xsd"
version="1.2">
<interceptors>
<class>com.example.MyInterceptor</class>
</interceptors>
</beans>在使用拦截器的应用程序中，可以通过将@Interceptors注解添加到类或方法上来应用拦截器的功能。
xxx
45.JavaEE中的beans.xml
在JavaEE中，beans.xml是一个配置文件，用于定义和配置CDI（Contexts and Dependency Injection）容器中的Bean（组件）。
beans.xml文件的作用如下：
- 启用CDI：beans.xml文件是启用CDI容器的必需文件。当项目中存在beans.xml文件时，CDI容器会被自动启用，并对beans.xml中定义的Bean进行管理。
- 声明Bean的作用域：在beans.xml中，可以使用元素下的、和子元素来声明Bean的作用域。这些作用域包括应用程序作用域（@ApplicationScoped）、会话作用域（@SessionScoped）、请求作用域（@RequestScoped）等。
- 配置替代Bean：通过元素，在beans.xml中可以配置备用（替代）Bean。当某个Bean不可用时，CDI容器会自动替换为备用Bean。
- 配置装饰器：通过元素，在beans.xml中可以配置装饰器，用于对已有Bean进行包装和增强。装饰器可以用于实现一些横切关注点（cross-cutting concerns），如事务管理、日志记录等。
- 配置拦截器：通过元素，在beans.xml中可以配置拦截器，用于在方法调用前后添加额外逻辑。拦截器可以用于实现类似AOP（面向切面编程）的功能，例如安全验证、性能监控等。
- 其他配置：beans.xml还可以用于配置其他CDI相关的应用程序级别的属性，比如开启/禁用CDI容器中的某些特性。
需要注意的是，JavaEE 7及其以后的版本中已经不再强制要求使用beans.xml文件。如果项目中没有beans.xml文件，CDI容器的工作将会基于默认的约定和规则进行。
xxx
46.什么是CDI 容器
CDI（Contexts and Dependency Injection）容器是JavaEE中的一种机制，用于管理应用程序中的Bean（组件）的生命周期、作用域和依赖关系。CDI提供了一种依赖注入（Dependency Injection）的方式，可以更方便地管理和组织代码，提高代码的可维护性和可测试性。
CDI容器的主要功能包括：
- 生命周期管理：CDI容器负责管理Bean的创建、销毁和垃圾回收等生命周期过程。根据Bean的作用域（如应用程序作用域、会话作用域、请求作用域等），CDI容器会自动创建和销毁Bean实例。
- 作用域管理：CDI容器支持不同的作用域，如@ApplicationScoped、@SessionScoped、@RequestScoped等。通过定义Bean的作用域，可以控制Bean的生命周期和共享方式。
- 依赖注入：CDI容器可以自动解决Bean之间的依赖关系。当某个Bean依赖于其他Bean时，CDI容器会负责自动注入依赖的Bean实例。
- 事件通知：CDI容器支持发布和监听事件机制。Bean可以发布事件，而其他Bean可以订阅（监听）这些事件。当事件发布时，CDI容器会自动触发相关Bean的处理逻辑。
- 替代和装饰：CDI容器支持通过配置进行Bean的替代和装饰，以实现业务逻辑的动态替换和增强。通过替代，可以在不修改代码的情况下改变Bean的实现。通过装饰，可以在Bean的基础上添加额外功能。
- 拦截器：CDI容器支持在方法调用前后添加拦截器。通过拦截器，可以在不修改Bean代码的情况下增加额外的逻辑，例如验证、日志记录、性能监控等。
总结来说，CDI容器是JavaEE中用于管理Bean的容器，通过提供依赖注入、作用域管理、生命周期管理等功能，可以更方便地组织和管理应用程序中的组件。
xxx
47.byte 127 + 1 = -128
127 0111，1111 + 1 = 1000，0000
计算机内部储存中，负数以其补码的形式存在
- 原码：将一个整数，转换成
二进制，就是其原码。- 反码：正数的反码就是其原码；
负数的反码是将原码中，除符号位以外，每一位取反。- 补码：正数的补码就是其原码；
负数的反码+1就是补码
===
48.XXX
xxx
49.XXX
xxx
■其他3（各种错误）
1.【404错误】PWC6117: File "null" not found
【404错误】PWC6117: File "null" not found_已解决_博问_博客园
2.
3.
■其他4（各种工具）
1.
扫一扫
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
