程序地带

Spring笔记(10) - 日志体系


一、概况

  在项目开发当中,日志对于我们开发或运维人员来说,是一个必不可少的工具。在线下我们可以通过 debug 来查找排除问题,但对于线上系统来说,我们只能通过日志分析来查找问题,我们可以通过日志打印来获取我们需要的信息来判断、分析系统运行结果是否正常或哪里出现了问题,可以定位到具体问题和位置。


  当前流行的日志框架有:


jul(java util logging)
log4j
log4j2
jcl(Jakarta Commons Logging)       
logback
slf4j
二、应用和探讨

  1.jul(java util logging)


  java自带的日志记录技术(java.util.logging.Logger),可以直接记录日志;功能比较太过于简单,不支持占位符显示,拓展性比较差;


import java.util.logging.Logger;
public class JUL {
public static void main(String[] args) {
Logger logger = Logger.getLogger("JUL");
logger.info("java util logging");
}
}


  2.log4j


  不支持使用占位符,在高并发日志量大的情况存在bug,容易导致内存、CPU冲高;


  使用 log4j 需要 pom 文件中引入 log4j 所需要的jar包和引入 log4j 的配置文件 log4j.properties


pom.xml
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
log4j.properties
log4j.rootLogger = info,stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
import org.apache.log4j.Logger;
public class Log4j {
public static void main(String[] args) {
Logger logger = Logger.getLogger(Log4j.class);
logger.info("log4j");
}
}


记住 jul 和 log4j 日志输出格式的差别,颜色不一致:jul 输出日志为红色,log4j 输出日志是白色;

  3.log4j2 


  log4j2 和 log4j 是同一个作者开发,只不过log4j2是重新架构的一款日志组件,改进了log4j的bug,以及吸取了优秀的logback的设计重新推出的一款新组件,在效率和性能上有了很大的提升;


  必须同时依赖 log4j-core 和 log4j-api,否则报错:“ERROR StatusLogger Log4j2 could not find a logging implementation”;


pom.xml
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.13.2</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.9.1</version>
</dependency>

 同时需要配置文件和测试代码:log4j2.xml、Log4j2.java 


<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
</Console>
</Appenders>
<Loggers>
<Root level="info">
<AppenderRef ref="Console" />
</Root>
</Loggers>
</Configuration>
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Log4j2 {
public static void main(String[] args) {
Logger logger = LogManager.getLogger("Log4j2");
logger.info("log4j2");
}
}

 


  4.jcl(Jakarta Commons Logging)


  Spring Framework 4.x 版本依赖了commons-logging.jar;Spring Framework 5.x 版本 依赖了spring-jcl.jar;


    Spring Framework 4.x :


      


    Spring Framework 5.x :


    


    1.commons-logging.jar:Spring Framework 4.x 


pom.xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.20.RELEASE</version>
</dependency>

<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class JCL {
public static void main(String[] args) {
Log log = LogFactory.getLog("JCL");
log.info("jakatra common logging");
}
}


    跟上面的jul输出格式一致;


    探讨:为什么 jcl 的输出格式是 jul 格式呢?


    接下来从源码来进行分析:从 LogFactory.getLog("JCL") 开始,从下面可以看出是从工厂


LogFactory:
public static Log getLog(String name) throws LogConfigurationException {
return getFactory().getInstance(name);
}
   getInstance(name)是一个抽象方法,看它的实现方法:
LogFactory:
public abstract Log getInstance(String name)
throws LogConfigurationException;
LogFactoryImpl:
public Log getInstance(String name) throws LogConfigurationException {
Log instance = (Log) instances.get(name);//开始是null
if (instance == null) {
instance = newInstance(name);//创建实例
instances.put(name, instance);//instances是一个Hashtable,实例放入缓存中
}
return instance;
}

    下面的代码就一行重要:


LogFactoryImpl:
protected Log newInstance(String name) throws LogConfigurationException {
Log instance;
try {
if (logConstructor == null) {
instance = discoverLogImplementation(name);//创建实例
}
else {
Object params[] = { name };
instance = (Log) logConstructor.newInstance(params);
}
if (logMethod != null) {
Object params[] = { this };
logMethod.invoke(instance, params);
}
return instance;
} catch (LogConfigurationException lce) {
// this type of exception means there was a problem in discovery
// and we"ve already output diagnostics about the issue, etc.;
// just pass it on
throw lce;
} catch (InvocationTargetException e) {
// A problem occurred invoking the Constructor or Method
// previously discovered
Throwable c = e.getTargetException();
throw new LogConfigurationException(c == null ? e : c);
} catch (Throwable t) {
handleThrowable(t); // may re-throw t
// A problem occurred invoking the Constructor or Method
// previously discovered
throw new LogConfigurationException(t);
}
}

    在下面的代码中可以看到实例的创建是从classesToDiscover遍历获取来的:


LogFactoryImpl:
private Log discoverLogImplementation(String logCategory)
throws LogConfigurationException {
if (isDiagnosticsEnabled()) {
logDiagnostic("Discovering a Log implementation...");
}
initConfiguration();
Log result = null;
// See if the user specified the Log implementation to use
String specifiedLogClassName = findUserSpecifiedLogClassName();
if (specifiedLogClassName != null) {
if (isDiagnosticsEnabled()) {
logDiagnostic("Attempting to load user-specified log class "" +
specifiedLogClassName + ""...");
}
result = createLogFromClass(specifiedLogClassName,
logCategory,
true);
if (result == null) {
StringBuffer messageBuffer = new StringBuffer("User-specified log class "");
messageBuffer.append(specifiedLogClassName);
messageBuffer.append("" cannot be found or is not useable.");
// Mistyping or misspelling names is a common fault.
// Construct a good error message, if we can
informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_LOG4J_LOGGER);
informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_JDK14_LOGGER);
informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_LUMBERJACK_LOGGER);
informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_SIMPLE_LOGGER);
throw new LogConfigurationException(messageBuffer.toString());
}
return result;
}
if (isDiagnosticsEnabled()) {
logDiagnostic(
"No user-specified Log implementation; performing discovery" +
" using the standard supported logging implementations...");
}
for(int i=0; i<classesToDiscover.length && result == null; ++i) {
result = createLogFromClass(classesToDiscover[i], logCategory, true);//创建实例
}
if (result == null) {
throw new LogConfigurationException
("No suitable Log implementation");
}
return result;
}

    从 classesToDiscover 数组中可以看到,数组存放具体的日志框架的类名,通过循环数组依次去匹配这些类名是否在项目中被依赖了,如果找到依赖则直接使用,有先后顺序,log4j>jul。


LogFactoryImpl:
private static final String LOGGING_IMPL_LOG4J_LOGGER = "org.apache.commons.logging.impl.Log4JLogger";
private static final String[] classesToDiscover = {
LOGGING_IMPL_LOG4J_LOGGER,
"org.apache.commons.logging.impl.Jdk14Logger",
"org.apache.commons.logging.impl.Jdk13LumberjackLogger",
"org.apache.commons.logging.impl.SimpleLog"
};

    下面使用commons-logging.jar和 log4j :下面的运行结果验证了上面的源码


pom.xml:
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>


    2.spring-jcl.jar:Spring Framework 5.x


pom.xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jcl</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class JCL {
public static void main(String[] args) {
Log log = LogFactory.getLog("JCL");
log.info("jakatra common logging");
}
}

   从下图可以看出,spring-jcl 默认还是使用 jul:



  接下来还是从源码来进行分析查看它的运行机制:从 LogFactory.getLog("JCL")开始,从下面可以看到它是从一个适配器获取日志对象的


public static Log getLog(String name) {
return LogAdapter.createLog(name);

  从下面代码可以看出,LogAdapter 在初始化时,会执行一个 static 的代码块,设置 logApi 的值,依次用 log4j2,slf4j-LAL(可以将 log4j 桥接到 slf4j),slf4j 去反射判断是否存在对应依赖,如果有则设置 logApi 为对应值,否则默认为 jul,然后在 createLog 时,switch-case 根据 logApi 去获取 log 对象,默认是 jul 来实现。


LogAdapter:
private static final String LOG4J_SPI = "org.apache.logging.log4j.spi.ExtendedLogger";
private static final String LOG4J_SLF4J_PROVIDER = "org.apache.logging.slf4j.SLF4JProvider";
private static final String SLF4J_SPI = "org.slf4j.spi.LocationAwareLogger";
private static final String SLF4J_API = "org.slf4j.Logger";
private static final LogApi logApi;
static {
if (isPresent(LOG4J_SPI)) {
if (isPresent(LOG4J_SLF4J_PROVIDER) && isPresent(SLF4J_SPI)) {
// log4j-to-slf4j bridge -> we"ll rather go with the SLF4J SPI;
// however, we still prefer Log4j over the plain SLF4J API since
// the latter does not have location awareness support.
logApi = LogApi.SLF4J_LAL;
}
else {
// Use Log4j 2.x directly, including location awareness support
logApi = LogApi.LOG4J;//log4j2
}
}
else if (isPresent(SLF4J_SPI)) {
// Full SLF4J SPI including location awareness support
logApi = LogApi.SLF4J_LAL;
}
else if (isPresent(SLF4J_API)) {
// Minimal SLF4J API without location awareness support
logApi = LogApi.SLF4J;
}
else {
// java.util.logging as default
logApi = LogApi.JUL;
}
}
//加载类:加载到指定的类返回true,否则返回false(加载不到指定类会抛出异常)
private static boolean isPresent(String className) {
try {
Class.forName(className, false, LogAdapter.class.getClassLoader());
return true;
}
catch (ClassNotFoundException ex) {
return false;
}
}
public static Log createLog(String name) {
switch (logApi) {
case LOG4J://log4j2
return Log4jAdapter.createLog(name);
case SLF4J_LAL:
return Slf4jAdapter.createLocationAwareLog(name);
case SLF4J:
return Slf4jAdapter.createLog(name);
default:
// Defensively use lazy-initializing adapter class here as well since the
// java.logging module is not present by default on JDK 9. We are requiring
// its presence if neither Log4j nor SLF4J is available; however, in the
// case of Log4j or SLF4J, we are trying to prevent early initialization
// of the JavaUtilLog adapter - e.g. by a JVM in debug mode - when eagerly
// trying to parse the bytecode for all the cases of this switch clause.
return JavaUtilAdapter.createLog(name);
}
}

   总结:


    commons-logging.jar(Spring Framework 4.x )封装了一个静态数组(支持 jul 和log4j),然后依次循环遍历反射对应的依赖,如果对应依赖存在则返回对应实现,默认为 jul,其中 log4j>jul;


    spring-jcl.jar(Spring Framework 5.x)修改了commons-logging.jar,通过适配器获取日志对象,支持 jul 和 log4j2(不支持 log4j,如果项目需要 log4j,需要 slf4j 配合使用),还拓展支持 slf4j,有着更好的扩展性和兼容性;


    如下案例: 


<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
log4j.properties:
log4j.rootLogger = Console,stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout 
@Configuration
@ComponentScan("com.hrh.log")
public class Config {
}
public class Test {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
context.start();
}
}

 


    当上面的依赖变为 Spring Framework 4.x 时是可以打印日志:


<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.20.RELEASE</version>
</dependency>

 


    Spring Framework 5.x 下log4j 配合 slf4j 使用输出日志,上面的pom依赖修改为:


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>

 


  5.logback


  log4j 的进化版,logback 除了具备 log4j 的所有优点之外,还解决了 log4j 不能使用占位符的问题。


  logback-classic依赖和logback.xml配置文件


pom.xml
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.1.7</version>
</dependency>
logback.xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<Pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</Pattern>
</layout>
</appender>
<logger name="com.hrh.log" level="TRACE"/>
<root level="debug">
<appender-ref ref="STDOUT" />
</root>
</configuration>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LogBack {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger("logBack");
logger.trace("Trace Level.");
logger.debug("Debug Level.");
logger.info("Info Level.");
logger.warn("Warn Level.");
logger.error("Error Level.");
logger.info("{},it"s OK.","Hi");//使用{}做占位符
}
}

 


  6.slf4j


   为了方便原先直接使用日志库(日志的核心功能实现: jul、log4j、log4j2、logback等)输出日志的形式转换为日志门面(slf4j、jcl)输出的形式提供的适配器。


  前面的 jul、log4j、log4j2、logback 是实现日志的日志库,简单日志可以使用 jul,复杂日志实现可以使用 logback 或 log4j2。很多时候我们的项目是从简单到复杂一代代迭代过来的,日志实现也是从简单到复杂,开始我们使用jul,后面系统复杂了我们需要使用 log4j2 日志框架,这时候我们如何将原来的日志输出在新的日志架构下实现呢?


  一个死板的方法是对代码一行行进行修改,把之前用 jul 的日志代码全部修改成 log4j2 的日志接口。但是这种方式不仅效率低下,而且做的工作都是重复性的工作,实际工作中不采用该方式。


  这时候我们就需要一个叫做 slf4j(Simple Logging Facade for Java,即Java简单日志记录接口集,也可以叫日志门面)的东西了,它是一个日志的接口规范,它对用户提供了统一的日志接口(使用Facade门面设计模式),屏蔽了底层不同日志组件的差异和实现细节,使用者无需关注底层实现的具体日志库。


  slf4j本身不记录日志,通过绑定器绑定一个具体的日志框架来完成日志记录。即slf4j 允许最终用户在部署时插入所需的日志框架,如果在项目中使用 slf4j 必须加一个依赖jar,即 slf4j-api-xxx.jar。而当我们需要更换日志组件的时候,我们只需要更换一个具体的日志组件 jar 包就可以了。


  比如说我们现在有个 app,通过 slf4j 打印日志,slf4j 需要通过一个绑定器(slf4j-jdk14-1.8.0-beta2)来绑定到我们的 jul 来输出日志。如果这时候需要在 app 中集成 spring4(spring4是利用jcl来打印日志的),这时候呢,考虑到系统的日志统一,可以使用桥接器(jcl-over-slf4j)将 jcl 桥接到 slf4j 来,然后通过 binding 到 jul 来输出日志,保证系统日志风格统一。



 


  下面是绑定类型(日志门面适配器)介绍:


绑定类型
说明
slf4j-log4j12-xxx.jar
绑定log4j,依赖log4j-xxx.jar,输出log4j日志
slf4j-jdk14-xxx.jar
绑定jul,输出jul日志
slf4j-jcl-xxx.jar
绑定jcl,默认输出jul日志,有log4j则输出log4j
logback-classic-xxx.jar
绑定logback,依赖logback-core-xxx.jar,输出logback日志


  下面是桥接类型(日志库适配器)介绍:


  比如左上角的第一个是将 jcl(或log4j、jul) 桥接到 slf4j,最后统一输出为 logback 日志;



  所以综上所述:


    绑定器绑定最后输出的日志类型;


    桥接器就是将指定日志类型桥接到 slf4j,最后统一输出绑定器绑定的日志类型,可以解释为指定日志类型输出的日志转换为绑定器绑定的日志类型;


    应用宜采用日志桥接、适配(绑定)机制,将 jul、log4j、jcl 等日志框架桥接到 slf4j,适配性能更高的 log4j2 日志输出框架打印;


  小贴士:对于日志量大的勿输出到控制台(Console);


  下面是几个简单案例实现:


1)slf4j+jul


pom.xml
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-jdk14</artifactId>
<version>1.7.21</version>
</dependency>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Slf4jJULLog {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(Slf4jJULLog.class);
logger.trace("Trace Level.");
logger.info("Info Level.");
logger.warn("Warn Level.");
logger.error("Error Level.");
}
}


2)slf4j+log4j


pom.xml
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
log4j.xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
</Console>
</Appenders>
<Loggers>
<Root level="info">
<AppenderRef ref="Console" />
</Root>
</Loggers>
</Configuration>
public class Slf4jLog4JLog {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(Slf4jLog4JLog.class);
logger.trace("Trace Level.");
logger.info("Info Level.");
logger.warn("Warn Level.");
logger.error("Error Level.");
}
}


  注意:当我们使用slf4j跟其他日志实现来搭建日志系统时,可能会存在一些循环引用导致栈溢出的问题。


  如下案例:


pom.xml
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j</artifactId>
<version>1.7.25</version>
</dependency>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Slf4jLog4JLog {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(Slf4jLog4JLog.class);
logger.trace("Trace Level.");
logger.info("Info Level.");
logger.warn("Warn Level.");
logger.error("Error Level.");
}
}


   上面就是一个由于循环引用导致栈溢出的错误,这时因为绑定器绑定 log4j 时在 log4j 又经过桥接器接到 slf4j,然后又经过绑定器,依次循环,最后栈溢出。


   这个问题在实际场景中较常见,比如我们一个 app 使用 slf4j 绑定器绑定到 log4j,最后通过 log4j 输出日志,这时有个 jar 包 X1,使用 slf4j 绑定输出到 jul,然后 X2需要集成 X2,X2 使用 log4j 输出日志,X1 在集成 X2时,使用桥接器(log4j-over-slf4j),保证 X1 的日志最后都是通过 jul 输出的。这时候app 集成 X1 便会出现 log4j 的桥接器和绑定器共存的情况,便会出现上面栈溢出的错误,这时候我们就需要修改我们的 app 了。



  最后来下总结:




 三.扩展

  log4j2更多详情参考:log4j2 的使用【超详细图文】


  logback更多详情参考:logback的使用和logback.xml详解


版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/huangrenhui/p/14382457.html

随机推荐

C++学习记录

2021/01/21一、如何计算一个类所占字节大小?空类占一个字节,其他情况字节大小计算如下(遵循内存对齐原则) https://my.osch...

Liu_Mir 阅读(717)

ENVI学习总结(十)——遥感图像监督分类

10. 遥感图像监督分类10.1 内容介绍监督分类,又称训练分类法,用被确认类别的样本像元去识别其他未知类别像元的过程。它就是在分类之前通过目视判读和野外调查,...

sysun 阅读(989)

二叉堆:动态维护集合最值的利器

二叉堆:动态维护集合最值的利器堆排序是利用堆这种数据结构完成的排序。所以,在了解堆排序之前,我们需要先了解“堆(Heap)”这种数...

珠穆 阅读(413)

JavaEE_day_16 (常用API、异常机制)

1.日期,时间类Date略,查找API文件即可2.枚举类Enum定义常量的类//枚举类finalclassResult{publicstaticfinalStringSUCCESS="...

脱氧核糖不酸 阅读(572)

配置pvst详解

 配置pvst在学习pvst之前,先要学习一下stpSTP生成树  思科默认有stp配置 1.选择根网桥(rootbridge)(这个是必须的配...

贼求笨 阅读(569)

如何搞定Z折卷圆类连续模?

如何搞定Z折卷圆类连续模?我们先来看下这个产品的三视图:相信大家看完三视图后应该都清楚了这个产品有一些什么难点吧?小编在这里总结一下这些难点1、这个产品时先卷...

Trouvaille_a 阅读(578)

Leetcode精选50题-Day10

Leetcode精选50题-Day10121买卖股票的最佳时机1.[题目描述](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-s...

木姑娘 阅读(351)

java之合并两个数组

在Java中,如何把两个String[]合并为一个?看起来是一个很简单的问题。但是如何才能把代码写得高效简洁,却还是值得思考的。这里介绍四种方法,...

casesay 阅读(898)

目前主流企业使用最高频的面试题库

面试题大全500道今天分享给大家的都是目前主流企业使用最高频的面试题库,也都是Java版本升级之后,重新整理归纳的最新答案,会让面试者少走很多不必要的弯路。同...

javachengzi 阅读(516)

JAVA 注解

注解概述注解很厉害,它可以增强我们的java代码,同时利用反射技术可以扩充实现很多功能。它们被广泛应用于三大框架底层。传统我们通过xml文本文件声明方式,而现...

爱编程真的太好了 阅读(250)