ini复制代码​

CYourClass::~CYourClass()
{
    for(IMG_VECTOR::iterator it = m_arImage.begin(); it != m_arImage.end(); it++)
        delete *it;
    for(HGLB_VECTOR::iterator it = m_arGlobal.begin(); it != m_arGlobal.end(); it++)
    {
        ::GlobalUnlock(*it);
        ::GlobalFree(*it);
    }
}


void CYourClass::AddImage(HMODULE hInst, UINT nResourceID, LPCTSTR lpType)
{
    if(lpType == RT_BITMAP)
    {
        //GDI+ can not load RT_BITMAP resouce, 
        //because they are predefined resource, 
        //they don't contains the image file header.
        assert(FALSE);
        return;
    }

    HRSRC hResource = ::FindResource(hInst, MAKEINTRESOURCE(nResourceID), lpType);
    if (!hResource)
        return;

    DWORD imageSize = ::SizeofResource(hInst, hResource);
    if (!imageSize)
        return;

    const void* pResourceData = ::LockResource(::LoadResource(hInst, hResource));
    if (!pResourceData)
        return;

    HGLOBAL hBuffer = ::GlobalAlloc(GMEM_FIXED, imageSize);
    if (NULL == hBuffer)
        return;

    void* pBuffer = ::GlobalLock(hBuffer);
    if (pBuffer)
    {
        CopyMemory(pBuffer, pResourceData, imageSize);
        IStream* pStream = NULL;
        if (::CreateStreamOnHGlobal(hBuffer, FALSE, &pStream) == S_OK)
        {
            Gdiplus::Image * pImage = Gdiplus::Image::FromStream(pStream);
            pStream->Release();
            if (pImage)
            { 
                if (pImage->GetLastStatus() == Gdiplus::Ok &&
                    pImage->GetWidth() > 0)
                {
                    m_arImage.push_back(pImage);

                    //it seems the image will take usage of the global memory.
                    //so the global memory should be kept until the image destroy.
                    //GDI++此种打开本地文件的方式占用了这片内存，只有在你销毁图片时才能销毁这片    
                    //内存，否则会破坏你的图片，导致显示异常
                    m_arGlobal.push_back(hBuffer);
                    return;
                }

                delete pImage;
            }
        }
        ::GlobalUnlock(hBuffer);
    }
    ::GlobalFree(hBuffer);
}

​

ini复制代码@ResponseBody
    @RequestMapping(value = "/xxx")
    public BaseResp unDirectExport(Date date, HttpServletResponse response) throws Exception {
        String fileName = xxx;
        ResponseUtil.setMultipartHeader(response, fileName);
        List<T> list = xxxService.query(xx);
      
        //按某个条件分组
        Map<String, List<T>> map = list.stream().collect(Collectors.groupingBy(T::getXXX));
        exportExcel(response, map);
        return BaseResp.succResp();
    }

    private void exportExcel(HttpServletResponse response, Map<String, List<T>> map) throws IOException {
        //Excel sheet 标题
        String[] headers = {""};
        ServletOutputStream outputStream = response.getOutputStream();
        ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
        try {
            map.forEach((k, v) -> {
                //新建一个Excel 并设置下sheet头
                HSSFWorkbook workbook = createExcelAndSetHeaders(headers, k);
                //向sheet中 继续填充对象的数据
                setSheetCellValue(workbook.getSheet(k), v);
                try {
                    //重点开始，创建压缩文件
                    ZipEntry zipEntry = new ZipEntry(k + ".xls");
                    zipOutputStream.putNextEntry(zipEntry);
                } catch (IOException e) {
                    logger.error("向XXX压缩包中添加Excel失败");
                    throw new Exception("向XXX压缩包中添加Excel失败");
                }
                try {
                    //写入一个压缩文件
                    workbook.write(zipOutputStream);
                } catch (IOException e) {
                    logger.error("向zipOutputStream中写入流数据失败");
                    throw new Exception("向zipOutputStream中写入流数据失败");
                }
            });
            zipOutputStream.flush();
        } catch (Exception e) {
            //重复丢出异常，有点多余，但是为了套上try catch finally 关闭数据流
            logger.error("导出XXX失败,原因" + e.getErrorCode());
            throw new Exception("导出XXX失败，原因：" + e.getErrorCode());
        } finally {
            //关闭数据流，注意关闭的顺序
            zipOutputStream.close();
            outputStream.close();
        }
    }

    private HSSFWorkbook createExcelAndSetHeaders(String[] headers, String sheetName) {
        HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
        HSSFSheet hssfSheet = hssfWorkbook.createSheet(sheetName);
        HSSFRow row0 = hssfSheet.createRow(0);
        for (int i = 0; i < headers.length; i++) {
            HSSFCell cellHeader = row0.createCell(i);
            cellHeader.setCellValue(headers[i]);
        }
        return hssfWorkbook;
    }

    private void setSheetCellValue(HSSFSheet hssfSheet, List<T> dtos) {
        for (T dto : dtos) {
            //从当前sheet页的最后一行后新增一行，开始填充数据
            HSSFRow row = hssfSheet.createRow(hssfSheet.getLastRowNum() + 1);
            int count = -1;
            row.createCell(++count).setCellValue(dto.getXXX);
            row.createCell(++count).setCellValue(dto.getXXX);
            row.createCell(++count).setCellValue(dto.getXXX);
            row.createCell(++count).setCellValue(dto.getXXX);
            row.createCell(++count).setCellValuedto.getXXX);
        }
    }

java复制代码import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

/**
 * @author zhaojq
 * @email zhaojq@tsintergy.com
 * @date 2019 2019/10/14 17:11
 */
public class ResponseUtil {

    private ResponseUtil() {
    }
    public static void setMultipartHeader(HttpServletResponse response, String fileName) 	{
        try {
            response.setCharacterEncoding("utf-8");
            response.setContentType("multipart/form-data");
            response.setHeader("Content-Disposition", "attachment;filename*=UTF-8''" + URLEncoder.encode(fileName, "UTF-8"));
        } catch (UnsupportedEncodingException e) {
            throw new BusinessException("文件名编码异常");
        }
    }
}

java复制代码<!-- https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.0.3</version>
</dependency>

java复制代码        Cache<Object, Object> cache = Caffeine.newBuilder()
                //初始数量
                .initialCapacity(10)
                //最大条数
                .maximumSize(10)
                //PS：expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准。
                //最后一次写操作后经过指定时间过期
                .expireAfterWrite(1, TimeUnit.SECONDS)
                //最后一次读或写操作后经过指定时间过期
                .expireAfterAccess(1, TimeUnit.SECONDS)
                //监听缓存被移除
                .removalListener((key, val, removalCause) -> { })
                //记录命中
                .recordStats()
                .build();

        cache.put("1","张三");
        System.out.println(cache.getIfPresent("1"));
        System.out.println(cache.get("2",o -> "默认值"));

java复制代码LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache
        .refreshAfterWrite(10, TimeUnit.SECONDS)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .expireAfterAccess(10, TimeUnit.SECONDS)
        .maximumSize(10)
        //根据key查询数据库里面的值
        .build(key -> new Date().toString());

java复制代码AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔刷新缓存；仅支持LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        //根据key查询数据库里面的值
        .buildAsync(key -> {
            Thread.sleep(1000);
            return new Date().toString();
        });

//异步缓存返回的是CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);

java复制代码LoadingCache<String, String> cache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        //开启记录缓存命中率等信息
        .recordStats()
        //根据key查询数据库里面的值
        .build(key -> {
            Thread.sleep(1000);
            return new Date().toString();
        });


cache.put("1", "小明");
cache.get("1");

/*
 * hitCount :命中的次数
 * missCount:未命中次数
 * requestCount:请求次数
 * hitRate:命中率
 * missRate:丢失率
 * loadSuccessCount:成功加载新值的次数
 * loadExceptionCount:失败加载新值的次数
 * totalLoadCount:总条数
 * loadExceptionRate:失败加载新值的比率
 * totalLoadTime:全部加载时间
 * evictionCount:丢失的条数
 */
System.out.println(cache.stats());

java复制代码import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Scheduler;
import com.github.benmanes.caffeine.cache.Weigher;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.TimeUnit;

/**
 * @author yejunxi
 * @date 2021/7/23
 */
@Slf4j
public class CacheTest {


    /**
     * 缓存大小淘汰
     */
    @Test
    public void maximumSizeTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //超过10个后会使用W-TinyLFU算法进行淘汰
                .maximumSize(10)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();

        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
        }
        Thread.sleep(500);//缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
    }

    /**
     * 权重淘汰
     */
    @Test
    public void maximumWeightTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //限制总权重，若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
                .maximumWeight(100)
                .weigher((Weigher<Integer, Integer>) (key, value) -> key)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();

        //总权重其实是=所有缓存的权重加起来
        int maximumWeight = 0;
        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
            maximumWeight += i;
        }
        System.out.println("总权重=" + maximumWeight);
        Thread.sleep(500);//缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
    }


    /**
     * 访问后到期（每次访问都会重置时间，也就是说如果一直被访问就不会被淘汰）
     */
    @Test
    public void expireAfterAccessTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterAccess(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
                //若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);

                })
                .build();
        cache.put(1, 2);
        System.out.println(cache.getIfPresent(1));
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }

    /**
     * 写入后到期
     */
    @Test
    public void expireAfterWriteTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
                //若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        cache.put(1, 2);
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }
}

java复制代码private static int NUM = 0;

@Test
public void refreshAfterWriteTest() throws InterruptedException {
    LoadingCache<Integer, Integer> cache = Caffeine.newBuilder()
            .refreshAfterWrite(1, TimeUnit.SECONDS)
            //模拟获取数据，每次获取就自增1
            .build(integer -> ++NUM);

    //获取ID=1的值，由于缓存里还没有，所以会自动放入缓存
    System.out.println(cache.get(1));// 1

    // 延迟2秒后，理论上自动刷新缓存后取到的值是2
    // 但其实不是，值还是1，因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
    // 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
    Thread.sleep(2000);
    System.out.println(cache.getIfPresent(1));// 1

    //此时才会刷新缓存，而第一次拿到的还是旧值
    System.out.println(cache.getIfPresent(1));// 2
}

xml复制代码<!--缓存-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.0.3</version>
</dependency>

java复制代码@Configuration
public class CaffeineConfig {

    @Bean
    public CacheManager caffeineCacheManager() {
        List<CaffeineCache> caffeineCaches = new ArrayList<>();

        //可自行在yml或使用枚举设置多个缓存，不同名字的缓存的不同配置
        caffeineCaches.add(new CaffeineCache("cache1",
                Caffeine.newBuilder()
                        .expireAfterWrite(10, TimeUnit.SECONDS)
                        .build())
        );

        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(caffeineCaches);
        return cacheManager;
    }
}

java复制代码@Service
@Slf4j
public class StudentService {
    @Cacheable(value = "cache1")
    public String getNameById(int id) {
        log.info("从DB获取数据：id=" + id);
        return new Date().toString();
    }
}

xml复制代码<!-- 可以不引入caffine,j2cache默认使用2.x版本 -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.0.3</version>
</dependency>

<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-spring-boot2-starter</artifactId>
    <version>2.8.0-release</version>
</dependency>

<dependency>
    <groupId>net.oschina.j2cache</groupId>
    <artifactId>j2cache-core</artifactId>
    <version>2.8.0-release</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </exclusion>
    </exclusions>
</dependency>

yml复制代码j2cache:
  config-location: classpath:/j2cache-${spring.profiles.active}.properties
  # 开启对spring cahce的支持
  open-spring-cache: true
  # jedis 或 lettuce 对应在j2cache.properties 配置
  redis-client: lettuce
  # 是否允许null值
  allow-null-values: true
  # 是否开始二级缓存
  l2-cache-open: true
  #  如下配置在application.properties,可以选择缓存清除的模式
  #  * 缓存清除模式
  #  * active:主动清除，二级缓存过期主动通知各节点清除，优点在于所有节点可以同时收到缓存清除
  #  * passive:被动清除，一级缓存过期进行通知各节点清除一二级缓存
  #  * blend:两种模式一起运作，对于各个节点缓存准确性以及及时性要求高的可以使用（推荐使用前面两种模式中一种）
  cache-clean-mode: passive

ini复制代码#J2Cache configuration
# caffeine 本地缓存定义文件
caffeine.properties=/caffeine.properties
j2cache.broadcast=net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy
j2cache.L1.provider_class=caffeine
j2cache.L2.provider_class=net.oschina.j2cache.cache.support.redis.SpringRedisProvider
j2cache.L2.config_section=redis
# 序列化方式
j2cache.serialization=json
#########################################
# Redis connection configuration
#########################################
#########################################
# Redis Cluster Mode
#
# single -> single redis server
# sentinel -> master-slaves servers
# cluster -> cluster servers (数据库配置无效，使用 database = 0）
# sharded -> sharded servers  (密码、数据库必须在 hosts 中指定，且连接池配置无效 ;
# 例子：redis://user:password@127.0.0.1:6379/0）
# sharded需要指定cluster name  ：redis.cluster_name = mymaster
#########################################
redis.mode=single
# redis通知节点删除本地缓存通道名
redis.channel=j2cache
# redis缓存key前缀
redis.namespace=j2cache
## connection
#redis.hosts = 127.0.0.1:26378,127.0.0.1:26379,127.0.0.1:26380
redis.hosts=127.0.0.1:6379
redis.timeout=2000
redis.password=xfish311
redis.database=1

ini复制代码#########################################
# Caffeine configuration 定义本地缓存
# [name] = size, xxxx[s|m|h|d] （过期时间）
#########################################

default = 1000, 30m
cache1 = 1000, 30m

python复制代码>>> import os
>>> import os.path
>>> os.path.isabs("F:\JueJin")
True
>>> os.path.isdir("F:\Juejin")
True
>>> os.path.isdir("F:\Juejin\a.txt")
False
>>> os.path.exists("F:\Juejin")
True
>>> os.getcwd()
'F:\\Juejin'
>>> os.path.exists("a.txt")
True
>>> os.path.getsize(r"F:\JueJin\a.txt")
0
>>> os.path.getatime(r"F:\Juejin\a.txt")
1627867023.051934
>>> os.path.getmtime(r"F:\JueJin\a.txt")
1627867023.051934
>>> os.path.getctime(r"F:\JueJin\a.txt")
1627867023.051934

lua复制代码import os 
import os.path

python复制代码import os.path
import time

def Mylogger(path):

    rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))

    filepath = os.path.dirname(path) #去掉文件名，返回目录，在文件目录下
    print(filepath)

    filename = rq+"logger"+".log"  # 文件名

    file = os.path.join(filepath,filename) #创建文件

    print(file)

Mylogger(r"F:\JueJin\a.txt")

ini复制代码//log4j依赖
<dependency>
	<groupId>log4j</groupId>
  	<artifactId>log4j</artifactId>
   	<version>1.2.17</version>
</dependency>

//log4配置文件
log4j.rootLogger=info, stdout
#mybatis的sql级别（结果的日志级别为TRACE，SQL 语句的日志级别为DEBUG）
log4j.logger.com.log.dao=TRACE  
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

//log4j测试类
public static void main(String[] args) {
   	Logger log4j = Logger.getLogger("log4j");
    log4j.info("log4j");
}

//输出
2019-09-03 11:17:06,273 INFO [log4j] - log4j

typescript复制代码//jcl依赖
<dependency>
   <groupId>commons-logging</groupId>
   <artifactId>commons-logging</artifactId>
   <version>1.2</version>
</dependency>

//jcl测试类
public static void main(String[] args) {
	Log jcl = LogFactory.getLog("jcl");
	jcl.info("jcl");
}

//输出
（1）：2019-09-03 11:23:54,470 INFO [jcl] - jcl

（2）：九月 03, 2019 11:24:43 上午 jcl main
      信息: jcl

ini复制代码#LogFactory
public static Log getLog(String name) throws LogConfigurationException {
	//通过Factory获取instance实例
    return getFactory().getInstance(name);
}

#LogFactoryImpl
public Log getInstance(String name) throws LogConfigurationException {
	//一开始没有缓存，所以为null
    Log instance = (Log) instances.get(name);
    if (instance == null) {
    	//这里是重点，创建logger实例
        instance = newInstance(name);
        //放入到缓存中
        instances.put(name, instance);
    }
    return instance;
}

protected Log newInstance(String name) throws LogConfigurationException {
	Log instance;
	try {
		if (logConstructor == null) {
			//重要代码，发现log实现类
			instance = discoverLogImplementation(name);
		}
		else {
			Object params[] = { name };
		 	instance = (Log) logConstructor.newInstance(params);
		}
		if (logMethod != null) {
		 	Object params[] = { this };
		 	logMethod.invoke(instance, params);
		}
		return instance;
	}
}

private Log discoverLogImplementation(String logCategory)
        throws LogConfigurationException {
   if (isDiagnosticsEnabled()) {
        logDiagnostic("Discovering a Log implementation...");
    }
    initConfiguration();
    
    //需要返回的对象
    Log result = null;
    
    //查看用户是否指定要使用的日志实现
    String specifiedLogClassName = findUserSpecifiedLogClassName();
    if (specifiedLogClassName != null) {
        if (isDiagnosticsEnabled()) {
            logDiagnostic("");
        }
        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("");
    }
    //如果用户没有指定日志实现类，jcl使用默认的实现类（4个）,然后遍历依次创建对应的log实现类。
    for(int i=0; i<classesToDiscover.length && result == null; ++i) {
        result = createLogFromClass(classesToDiscover[i], logCategory, true);
    }
    if (result == null) {
        throw new LogConfigurationException("");
    }
    return result;
}

//jcl内部默认的4个log实现类。
private static final String[] classesToDiscover = {
	"org.apache.commons.logging.impl.Log4JLogger",
	"org.apache.commons.logging.impl.Jdk14Logger",
	"org.apache.commons.logging.impl.Jdk13LumberjackLogger",
	"org.apache.commons.logging.impl.SimpleLog"
};

//根据class创建log对象
private Log createLogFromClass(String logAdapterClassName,
                               String logCategory,
                               boolean affectState)
    throws LogConfigurationException {
    
    Object[] params = { logCategory };
    Log logAdapter = null;
    Constructor constructor = null;

    Class logAdapterClass = null;
    ClassLoader currentCL = getBaseClassLoader();

    for(;;) {       
        logDiagnostic("Trying to load '" + logAdapterClassName + "' from classloader " + objectId(currentCL));
        try {           
            Class c;
            try {
            	//通过class.forName加载log类
                c = Class.forName(logAdapterClassName, true, currentCL);
            } catch (ClassNotFoundException originalClassNotFoundException) {      
            	//表示找不到类（因为用户可能指定类log的实现类）       
                try {                   
                    c = Class.forName(logAdapterClassName);
                } catch (ClassNotFoundException secondaryClassNotFoundException) {                 
                    break;
                }
            }
            //拿到c的构造方法对象。然后通过构造对象来创建对象。（有参构造方法）
            constructor = c.getConstructor(logConstructorSignature);
            Object o = constructor.newInstance(params);       
            
            if (o instanceof Log) {
                logAdapterClass = c;
                logAdapter = (Log) o;
                break;
            }     
            handleFlawedHierarchy(currentCL, c);
        } catch (NoClassDefFoundError e) {
           
            String msg = e.getMessage();
            logDiagnostic("");
            break;
        } catch (ExceptionInInitializerError e) {         
            String msg = e.getMessage();
            logDiagnostic("");
            break;
        } catch (LogConfigurationException e) {           
            throw e;
        } catch (Throwable t) {
            handleThrowable(t);
            handleFlawedDiscovery(logAdapterClassName, currentCL, t);
        }
        if (currentCL == null) {
            break;
        }
        currentCL = getParentClassLoader(currentCL);
    }
    //返回创建的对象
    return logAdapter;
}

xml复制代码//slf4j依赖
<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactId>
   <version>1.7.25</version>
</dependency>

xml复制代码//slf4j依赖
<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactId>
   <version>1.7.25</version>
</dependency>

<!--slf4jbind绑定器，将slf4j绑定到jul-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>1.7.25</version>
</dependency>

<!--slf4jbind绑定器，将slf4j绑定到log4j-->
<!--<dependency>-->
<!--    <groupId>org.slf4j</groupId>-->
<!--    <artifactId>slf4j-log4j12</artif
<!--    <version>1.7.5</version>-->
<!--</dependency>-->

<!--slf4jbind绑定器，将slf4j绑定到jcl-->
<!--<dependency>-->
<!--    <groupId>org.slf4j</groupId>-->
<!--    <artifactId>slf4j-jcl</artifactI
<!--    <version>1.7.25</version>-->
<!--</dependency>-->

xml复制代码//项目A的依赖
//log4j
<dependency>
   <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

//jcl
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

//slf4j
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>

<!--slf4jbind绑定器，将slf4j绑定到jul-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>1.7.25</version>
</dependency>

xml复制代码//增加下面这个依赖即可：
<!--slf4j桥接器，将jcl桥接到slf4j-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.7.25</version>
</dependency>

java复制代码#AbstractApplicationContext
protected final Log logger = LogFactory.getLog(getClass());

#LogFactory（spring-jcl包下）
public static Log getLog(Class<?> clazz) {
	return getLog(clazz.getName());
}

public static Log getLog(String name) {
	switch (logApi) {
		//log4j2
		case LOG4J:
			return Log4jDelegate.createLog(name);
		//slf4j
		case SLF4J_LAL:
			return Slf4jDelegate.createLocationAwareLog(name);
		case SLF4J:
			return Slf4jDelegate.createLog(name);
		default:
			//默认是jul
			return JavaUtilDelegate.createLog(name);
	}
}

//默认是jul
private static LogApi logApi = LogApi.JUL;
//静态代码块，在类初始化的时候执行
static {
	ClassLoader cl = LogFactory.class.getClassLoader();
	try {
		// Try Log4j 2.x API（尝试加载log4j2）
		cl.loadClass("org.apache.logging.log4j.spi.ExtendedLogger");
		logApi = LogApi.LOG4J;
	}
	catch (ClassNotFoundException ex1) {
		try {
			// Try SLF4J 1.7 SPI（尝试加载slf4j）
			cl.loadClass("org.slf4j.spi.LocationAwareLogger");
			logApi = LogApi.SLF4J_LAL;
		}
		catch (ClassNotFoundException ex2) {
			try {
				// Try SLF4J 1.7 API（尝试加载slf4j）
				cl.loadClass("org.slf4j.Logger");
				logApi = LogApi.SLF4J;
			}
			catch (ClassNotFoundException ex3) {
				// Keep java.util.logging as default（如果都没有，就保持使用默认的jul）
			}
		}
	}
}

xml复制代码<!-- spring5的依赖 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.9.RELEASE</version>
</dependency>

<!-- log4j2依赖 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.8.2</version>
</dependency>

<!-- log4j2.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>

xml复制代码<!-- spring5的依赖 -->
<dependency>
  	<groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.9.RELEASE</version>
</dependency>

<!--slf4j依赖（可省略）-->
<dependency>
   	<groupId>org.slf4j</groupId>
   	<artifactId>slf4j-api</artifactId>
   	<version>1.7.25</version>
</dependency>

<!--slf4jbind绑定器，将slf4j绑定到log4j（已经包含了slf4j和log4j的依赖）-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.5</version>
</dependency>

typescript复制代码#LogFactory

private static void tryImplementation(Runnable runnable) {
	//关键代码  logConstructor == null 没有找到实现则继续找
	 if (logConstructor == null) {
	   try {
	     	runnable.run();
	   } catch (Throwable t) {
	     	// ignore
	   }
	 }
}

tryImplementation(new Runnable() {
	@Override
	public void run() {
		useSlf4jLogging();
	}
});

public static synchronized void useSlf4jLogging() {
 	setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
}

private static void setImplementation(Class<? extends Log> implClass) {
  try {
	    Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
	    Log log = candidate.newInstance(LogFactory.class.getName());
	    if (log.isDebugEnabled()) {
	      	log.debug("Logging initialized using '" + implClass + "' adapter.");
	    }
    	logConstructor = candidate;
  } catch (Throwable t) {
    	throw new LogException("Error setting Log implementation.  Cause: " + t, t);
  }
}

xml复制代码    <dependencies>
        <!-- https://mvnrepository.com/artifact/us.codecraft/webmagic-core -->
        <dependency>
            <groupId>us.codecraft</groupId>
            <artifactId>webmagic-core</artifactId>
            <version>0.7.3</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/us.codecraft/webmagic-extension -->
        <dependency>
            <groupId>us.codecraft</groupId>
            <artifactId>webmagic-extension</artifactId>
            <version>0.7.3</version>
        </dependency>
    </dependencies>

properties复制代码log4j.rootLogger=INFO,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] %m%n

java复制代码public class JobProcessor implements PageProcessor {
    public static void main(String[] args) {
        Spider.create(new JobProcessor())   // new一个自己所写的JobProcessor对象
                .addUrl("http://112.124.1.187/index.html")
                .run();
    }
    // 负责解析页面
    @Override
    public void process(Page page) {
        // 解析返回的数据page,并且把解析的结果放到 ResultItems 中
        page.putField("首页通知",page.getHtml().css("div.content h2").all());
    }
    // 这个，将就写着，入门案例嘛，后面讲到
    private Site site = Site.me();
    @Override
    public Site getSite() {
        return site;
    }
}

java复制代码page.putField("首页通知",page.getHtml().css("div.content h2").gt()　　// 一个元素（默认第一个）
page.putField("首页通知",page.getHtml().css("div.content h2").toString()　　// 一个元素（默认第一个）
page.putField("首页通知",page.getHtml().css("div.content h2").all()　　// 所有元素

java复制代码// 放在上面的 process 方法中执行。       
　　　　 // 获取链接
        // 这一行代码，获取，当前页面中抽取出来的带有其他 URL 地址的元素
        page.addTargetRequests(page.getHtml().css(".excerpt_ban p").links().all());
        // 这之间，做了一个跳转。下面的代码针对目标url地址的页面
        // 这一行代码，获取，目标 url 的HTML页面中，你要抽取的元素
        page.putField("链接抓取，博客标题",page.getHtml().css(".blog_title h4").all());

java复制代码    // 这个，将就写着，入门案例嘛，后面讲到
    private Site site = Site.me()
            .setCharset("utf-8")    // 设置编码
            .setTimeOut(10 * 1000)     // 设置超时时间，单位:毫秒
            .setSleepTime(10)     // 抓取间隔时间
            .setCycleRetryTimes(10 * 1000)   // 重试的时间
            .setRetryTimes(3)    // 重试次数
            ;

xml复制代码 <!--aop 切面-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

java复制代码@RestController
public class AopController {

    @RequestMapping("/hello")
    public String sayHello(){
        System.out.println("hello");
        return "hello";
    }
}

java复制代码@Aspect
@Component
public class AopAdvice {

    @Pointcut("execution (* com.shangguan.aop.controller.*.*(..))")
    public void test() {

    }

    @Before("test()")
    public void beforeAdvice() {
        System.out.println("beforeAdvice...");
    }

    @After("test()")
    public void afterAdvice() {
        System.out.println("afterAdvice...");
    }

    @Around("test()")
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
        System.out.println("before");
        try {
            proceedingJoinPoint.proceed();
        } catch (Throwable t) {
            t.printStackTrace();
        }
        System.out.println("after");
    }

}

java复制代码package cn.soboys.core;

import lombok.Data;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/18 18:48
 * 日志信息
 */
@Data
public class LogSubject {
    /**
     * 操作描述
     */
    private String description;

    /**
     * 操作用户
     */
    private String username;

    /**
     * 操作时间
     */
    private String startTime;

    /**
     * 消耗时间
     */
    private String spendTime;

    /**
     * URL
     */
    private String url;

    /**
     * 请求类型
     */
    private String method;

    /**
     * IP地址
     */
    private String ip;

    /**
     * 请求参数
     */
    private Object parameter;

    /**
     * 请求返回的结果
     */
    private Object result;

    /**
     * 城市
     */
    private String city;

    /**
     * 请求设备信息
     */
    private String device;



}

java复制代码package cn.soboys.core;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/18 14:52
 * 切面
 */
public class BaseAspectSupport {
    public Method resolveMethod(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature)point.getSignature();
        Class<?> targetClass = point.getTarget().getClass();

        Method method = getDeclaredMethod(targetClass, signature.getName(),
                signature.getMethod().getParameterTypes());
        if (method == null) {
            throw new IllegalStateException("无法解析目标方法: " + signature.getMethod().getName());
        }
        return method;
    }

    private Method getDeclaredMethod(Class<?> clazz, String name, Class<?>... parameterTypes) {
        try {
            return clazz.getDeclaredMethod(name, parameterTypes);
        } catch (NoSuchMethodException e) {
            Class<?> superClass = clazz.getSuperclass();
            if (superClass != null) {
                return getDeclaredMethod(superClass, name, parameterTypes);
            }
        }
        return null;
    }
}

java复制代码package cn.soboys.core;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.json.JSONUtil;
import cn.soboys.core.utils.HttpContextUtil;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/18 15:22
 * 全局日志记录器
 */
@Slf4j
@Aspect
@Component
public class GlobalLogAspect extends BaseAspectSupport {
    /**
     * 定义切面Pointcut
     */
    @Pointcut("execution(public * cn.soboys.mallapi.controller.*.*(..))")
    public void log() {

    }


    /**
     * 环绕通知
     *
     * @param joinPoint
     * @return
     */
    @Around("log()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {

        LogSubject logSubject = new LogSubject();
        //记录时间定时器
        TimeInterval timer = DateUtil.timer(true);
        //执行结果
        Object result = joinPoint.proceed();
        logSubject.setResult(result);
        //执行消耗时间
        String endTime = timer.intervalPretty();
        logSubject.setSpendTime(endTime);
        //执行参数
        Method method = resolveMethod(joinPoint);
        logSubject.setParameter(getParameter(method, joinPoint.getArgs()));

        HttpServletRequest request = HttpContextUtil.getRequest();
        // 接口请求时间
        logSubject.setStartTime(DateUtil.now());
        //请求链接
        logSubject.setUrl(request.getRequestURL().toString());
        //请求方法GET,POST等
        logSubject.setMethod(request.getMethod());
        //请求设备信息
        logSubject.setDevice(HttpContextUtil.getDevice());
        //请求地址
        logSubject.setIp(HttpContextUtil.getIpAddr());
        //接口描述
        if (method.isAnnotationPresent(ApiOperation.class)) {
            ApiOperation apiOperation = method.getAnnotation(ApiOperation.class);
            logSubject.setDescription(apiOperation.value());
        }

        String a = JSONUtil.toJsonPrettyStr(logSubject);
        log.info(a);
        return result;

    }


    /**
     * 根据方法和传入的参数获取请求参数
     */
    private Object getParameter(Method method, Object[] args) {
        List<Object> argList = new ArrayList<>();
        Parameter[] parameters = method.getParameters();
        Map<String, Object> map = new HashMap<>();
        for (int i = 0; i < parameters.length; i++) {
            //将RequestBody注解修饰的参数作为请求参数
            RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
            //将RequestParam注解修饰的参数作为请求参数
            RequestParam requestParam = parameters[i].getAnnotation(RequestParam.class);
            String key = parameters[i].getName();
            if (requestBody != null) {
                argList.add(args[i]);
            } else if (requestParam != null) {
                map.put(key, args[i]);
            } else {
                map.put(key, args[i]);
            }
        }
        if (map.size() > 0) {
            argList.add(map);
        }
        if (argList.size() == 0) {
            return null;
        } else if (argList.size() == 1) {
            return argList.get(0);
        } else {
            return argList;
        }
    }
}