java复制代码// Step 1 : 在 createBean 中对 applyBeanPostProcessorsBeforeInstantiation 进行处理
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

    // .... 省略部分逻辑 , 此处初始化代理类
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    
    // 此内将会调用 Step 2 创建逻辑 , 同时处理代理类
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);

    //........
    return beanInstance;

}


// Step 2 : 在 IOC 流程 initializeBean 中 , 会对 PostProcessors 进行处理
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

    //..........
    invokeInitMethods(beanName, wrappedBean, mbd);

    // 调用 applyBeanPostProcessorsAfterInitialization 处理 AfterPostProcessors
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

java复制代码for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
         // idp -> org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
        Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
         //..........
    }
}

java复制代码public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    Object cacheKey = getCacheKey(beanClass, beanName);

    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
         // 如果已经处理 , 此处直接返回
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        // isInfrastructureClass -> 不应该被代理的基础结构类
         // shouldSkip -> 注意 , 子类重写 shouldSkip , 用于跳过自动代理
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
             // PRO21001 -> advisedBeans 的作用
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    // 如果有一个自定义的TargetSource，那么在这里创建代理
    // TargetSource将以自定义的方式处理目标实例
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        // 自行定制 CustomTargetSource 逻辑后 , 即会在此处创建代理
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    return null;
}

java复制代码
C- getCustomTargetSource : 为bean实例创建目标源。如果设置，使用任何TargetSourceCreators
protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
    // 此处要求存在创建者,  需要在执行定制
    if (this.customTargetSourceCreators != null &&
        this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
        for (TargetSourceCreator tsc : this.customTargetSourceCreators) {
            // 通过创建者回去目标对象代理类
            TargetSource ts = tsc.getTargetSource(beanClass, beanName);
            if (ts != null) {
                return ts;
            }
        }
    }

    // 未定义 customTargetSource 会在此处直接返回
    return null;
}

java复制代码if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

java复制代码for (BeanPostProcessor processor : getBeanPostProcessors()) {
    // BeanPostProcessor -> org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
    Object current = processor.postProcessAfterInitialization(result, beanName);
    //........ 
}

java复制代码public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
         // cacheKey 用来标识
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

java复制代码
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 如果配置了通知 ,则创建Proxy 代理
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
         // 核心逻辑 , 创建代理 -> 2.2 Aop 代理类的创建
         // 可以看到 , 这里构建了一个 SingletonTargetSource -> PRO21002 : TargetSource 是什么 ?
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

java复制代码// advisedBeans 用于标识当前 Bean 的代理状态 , 该对象 key 为 getCacheKey 获取
Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);

- 如果无需代理 -> advisedBeans.put(cacheKey, Boolean.FALSE)
- 如果已经代理 -> advisedBeans.put(cacheKey, Boolean.TRUE)
- 最终无操作(没用注解标注) -> advisedBeans.put(cacheKey, Boolean.FALSE)

java复制代码M- getAdvicesAndAdvisorsForBean
Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName,TargetSource customTargetSource)
    ?- 返回给定的bean是否要被代理，要应用哪些附加通知(例如AOP Alliance拦截器)和建议器
    
// 该类主要有2个实现类 : AbstractAdvisorAutoProxyCreator , BeanNameAutoProxyCreator
    
protected Object[] getAdvicesAndAdvisorsForBean(
            Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

java复制代码protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    // Step 2-1 : 查询切面对应的所有的通知
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // Step 2-2 : 筛选与类对应的织入切点
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    // 空对象, 待实现
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

java复制代码protected List<Advisor> findCandidateAdvisors() {
    // 根据超类规则添加所有找到的Spring 通知
    List<Advisor> advisors = super.findCandidateAdvisors();
    // 为bean工厂中的所有AspectJ方面构建 通知
    if (this.aspectJAdvisorsBuilder != null) {
         // 2-1-1-1
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    }
    return advisors;
}

// 2-1-1-1  : 构建通知者
public List<Advisor> buildAspectJAdvisors() {
    List<String> aspectNames = this.aspectBeanNames;

    if (aspectNames == null) {
        synchronized (this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                List<Advisor> advisors = new ArrayList<>();
                aspectNames = new ArrayList<>();
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                            this.beanFactory, Object.class, true, false);
                for (String beanName : beanNames) {
                    if (!isEligibleBean(beanName)) {
                        continue;
                    }
                    // 需要在实例化缓存之前被处理
                    Class<?> beanType = this.beanFactory.getType(beanName);
                    if (beanType == null) {
                        continue;
                    }
                    // 过滤出切面 Bean  , debug 过程中会拿到我自己定义的切面
                    if (this.advisorFactory.isAspect(beanType)) {
                        aspectNames.add(beanName);
                        // 获取切面元数据 -> PIC0001
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                            // AspectInstanceFactory的子接口，它返回与aspectj注释类关联的AspectMetadata
                            MetadataAwareAspectInstanceFactory factory =
                                        new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                            // 获得所有得通知点 -> PIC0002
                            List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                            if (this.beanFactory.isSingleton(beanName)) {
                                // 此处成功放入缓存中
                                this.advisorsCache.put(beanName, classAdvisors);
                            }
                            else {
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            advisors.addAll(classAdvisors);
                        } else {
                            // Per target or per this.
                            if (this.beanFactory.isSingleton(beanName)) {
                                throw new IllegalArgumentException("Bean with name '" + beanName +
                                            "' is a singleton, but aspect instantiation model is not singleton");
                            }
                            MetadataAwareAspectInstanceFactory factory =
                                new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                            this.aspectFactoryCache.put(beanName, factory);
                            advisors.addAll(this.advisorFactory.getAdvisors(factory));
                        }
                    }
                }
                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }
    }

    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    
    // 循环 aspect 切面 , 添加通知
    List<Advisor> advisors = new ArrayList<>();
    for (String aspectName : aspectNames) {
        List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        } else {
            MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }
    return advisors;
}

java复制代码protected List<Advisor> findCandidateAdvisors() {
    return this.advisorRetrievalHelper.findAdvisorBeans();
}

java复制代码public List<Advisor> findAdvisorBeans() {
    // 确定advisor bean名称列表
    String[] advisorNames = this.cachedAdvisorBeanNames;
    if (advisorNames == null) {
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the auto-proxy creator apply to them!
        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                    this.beanFactory, Advisor.class, true, false);
        this.cachedAdvisorBeanNames = advisorNames;
    }
    if (advisorNames.length == 0) {
        return new ArrayList<>();
    }

    List<Advisor> advisors = new ArrayList<>();
    for (String name : advisorNames) {
        if (isEligibleBean(name)) {
            if (this.beanFactory.isCurrentlyInCreation(name)) {
                // log 省略
            } else {
                try {
                    advisors.add(this.beanFactory.getBean(name, Advisor.class));
                } catch (BeanCreationException ex) {
                    Throwable rootCause = ex.getMostSpecificCause();
                    if (rootCause instanceof BeanCurrentlyInCreationException) {
                        BeanCreationException bce = (BeanCreationException) rootCause;
                        String bceBeanName = bce.getBeanName();
                        if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                            // Ignore: indicates a reference back to the bean we're trying to advise.
                            // We want to find advisors other than the currently created bean itself.
                            continue;
                        }
                    }
                    throw ex;
                }
            }
        }
    }
    return advisors;
}

java复制代码
protected List<Advisor> findAdvisorsThatCanApply(
    List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

    ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    try {
        return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    } finally {
        ProxyCreationContext.setCurrentProxiedBeanName(null);
    }
}

java复制代码protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
    AnnotationAwareOrderComparator.sort(advisors);
    return advisors;
}

// [Pro] : AnnotationAwareOrderComparator 是什么 ?
AnnotationAwareOrderComparator是OrderComparator的扩展，它支持Spring的Ordered接口以及Order和Priority注释

java复制代码public class DefaultCustomTargetSource extends AbstractBeanFactoryBasedTargetSource {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public Object getTarget() throws Exception {
        logger.info("------> 进入 [DefaultCustomTargetSource] , 返回当前目标对象 <-------");
        return getBeanFactory().getBean(getTargetBeanName());
    }
}

java复制代码public class DefaultCustomerTargetSourceCreator extends AbstractBeanFactoryBasedTargetSourceCreator {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    protected AbstractBeanFactoryBasedTargetSource createBeanFactoryBasedTargetSource(Class<?> beanClass, String beanName) {
        logger.info("------> CustomerTargetSourceCreator build : [进入流程创建过程 , 返回默认资源类 DefaultCustomTargetSource] <-------");
        if (getBeanFactory() instanceof ConfigurableListableBeanFactory) {
            if (beanClass.isAssignableFrom(OtherService.class)) {
                return new DefaultCustomTargetSource();
            }
        }
        return null;
    }
}

java复制代码@Component
public class CustomTargetSourceCreatorConfig implements BeanPostProcessor, PriorityOrdered, BeanFactoryAware {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    private BeanFactory beanFactory;

    @Override
    public int getOrder() {
        return 45;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        logger.info("------> 进入 CustomTargetSourceCreatorConfig 初始化加载逻辑 , 返回默认创建者  <-------");
        if (bean instanceof AnnotationAwareAspectJAutoProxyCreator) {
            AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator = (AnnotationAwareAspectJAutoProxyCreator) bean;
            DefaultCustomerTargetSourceCreator customTargetSourceCreator = new DefaultCustomerTargetSourceCreator();
            customTargetSourceCreator.setBeanFactory(beanFactory);
            annotationAwareAspectJAutoProxyCreator.setCustomTargetSourceCreators(customTargetSourceCreator);
        }
        return bean;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
}

xml复制代码 <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.3</version>
  </dependency>

xml复制代码<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

xml复制代码#---------------数据库连接配置--------------
# 用户名
spring.datasource.username=root
# 密码
spring.datasource.password=root
# 连接url
spring.datasource.url=jdbc:mysql://localhost:3306/school?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
# 驱动名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

JAVA复制代码package cn.soboys.springbootmybatisplus.bean;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/25 10:08
 */

@TableName("student")
public class Student extends Model {
    @TableId(value = "student_id",type = IdType.AUTO)
    private Long studentId;
    @TableField("student_name")
    private String studentName;
    @TableField("age")
    private int age;
    @TableField("phone")
    private String phone;
    @TableField("addr")
    private String addr;


    public Long getStudentId() {
        return studentId;
    }

    public void setStudentId(Long studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }
}

java复制代码package cn.soboys.springbootmybatisplus.mapper;

import cn.soboys.springbootmybatisplus.bean.Student;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.mybatis.spring.annotation.MapperScan;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/25 10:53
 */
@Mapper
public interface StudentMapper extends BaseMapper<Student> {


}

java复制代码package cn.soboys.springbootmybatisplus.service;

import cn.soboys.springbootmybatisplus.bean.Student;
import com.baomidou.mybatisplus.extension.service.IService;
import org.springframework.stereotype.Service;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/25 10:59
 */

public interface IStudentService extends IService<Student> {
}

java复制代码package cn.soboys.springbootmybatisplus.service.impl;

import cn.soboys.springbootmybatisplus.bean.Student;
import cn.soboys.springbootmybatisplus.mapper.StudentMapper;
import cn.soboys.springbootmybatisplus.service.IStudentService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/25 13:35
 */
@Service
public class StudentServiceImpl extends ServiceImpl<StudentMapper,Student> implements IStudentService {
}

java复制代码package cn.soboys.springbootmybatisplus.controller;

import cn.soboys.springbootmybatisplus.bean.Student;

import cn.soboys.springbootmybatisplus.service.IStudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/25 11:09
 */
@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private IStudentService studentService;

    /**
     * 添加学生
     *
     * @param student
     * @return
     */
    @PostMapping("/add")
    public boolean addStudent(@RequestBody Student student) {
        boolean flag = studentService.save(student);
        return flag;
    }

    /**
     * 根据id更新学生信息
     *
     * @param student
     * @return
     */
    @PutMapping("/update")
    public boolean updateStudent(@RequestBody Student student) {
        //根据学生id更新学生
        boolean flag = studentService.updateById(student);
        return flag;
    }


    /**
     * 查找所有学生信息
     *
     * @return
     */
    @GetMapping("/list")
    public List<Student> list() {
        return studentService.list();
    }

    /**
     * 根据id删除学生信息
     *
     * @param studentId
     * @return
     */
    @DeleteMapping("/del/{studentId}")
    public boolean del(@PathVariable long studentId) {
        boolean flag = studentService.removeById(studentId);
        return flag;
    }

    /**
     * 根据id获取学生信息
     * @param studentId
     * @return
     */
    @GetMapping("{studentId}")
    public Student getStudentInfo(@PathVariable long studentId){
        return studentService.getById(studentId);
    }


}

java复制代码<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

java复制代码package cn.soboys.springbootmybatisplus.bean;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/25 10:08
 */

@TableName
@Data
public class Student extends Model {
    @TableId(type = IdType.AUTO)
    private Long studentId;
    private String studentName;
    private int age;
    private String phone;
    private String addr;
}

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

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
@MapperScan({"cn.soboys.springbootmybatisplus.mapper"})
public class SpringbootMybatisplusApplication {

    private static ApplicationContext applicationContext;

    public static void main(String[] args) {
        applicationContext = SpringApplication.run(SpringbootMybatisplusApplication.class, args);
        //displayAllBeans();
    }

    /**
     * 打印所以装载的bean
     */
    public static void displayAllBeans() {
        String[] allBeanNames = applicationContext.getBeanDefinitionNames();
        for (String beanName : allBeanNames) {
            System.out.println(beanName);
        }
    }
}

xml复制代码#---------------数据库连接配置--------------
#数据源类型
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
# 用户名
spring.datasource.username=root
# 密码
spring.datasource.password=root
# 连接url
spring.datasource.url=jdbc:mysql://localhost:3306/school?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
# 驱动名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#---------------数据库连接池HikariCP配置--------------
#最小空闲连接，默认值10，小于0或大于maximum-pool-size，都会重置为maximum-pool-size
spring.datasource.hikari.minimum-idle=10
#最大连接数，小于等于0会被重置为默认值10；大于零小于1会被重置为minimum-idle的值
spring.datasource.hikari.maximum-pool-size=20
#空闲连接超时时间，默认值600000单位毫秒（10分钟），
# 大于等于max-lifetime且max-lifetime>0，会被重置为0；不等于0且小于10秒，会被重置为10秒。
spring.datasource.hikari.idle-timeout=500000
#连接最大存活时间，不等于0且小于30秒，会被重置为默认值30分钟.设置应该比mysql设置的超时时间短
spring.datasource.hikari.max-lifetime=540000
#连接超时时间：毫秒，小于250毫秒，否则被重置为默认值30秒
spring.datasource.hikari.connection-timeout=60000
#用于测试连接是否可用的查询语句
spring.datasource.hikari.connection-test-query=SELECT 1

xml复制代码#--------------------mybatisPlus配置------------------
#mapper.xml 文件位置
mybatis-plus.mapper-locations=classpath:mapper/*.xml
#别名包扫描路径，通过该属性可以给包中的类注册别名
mybatis-plus.type-aliases-package=cn.soboys.springbootmybatisplus.bean
#控制台打印mybatisPlus LOGO
mybatis-plus.global-config.banner=true

java复制代码package cn.soboys.springbootmybatisplus.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/28 10:19
 */
@SpringBootConfiguration
public class MyBatisCfg {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

java复制代码/**
     * 分页查询每个班级学生信息
     * @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位(你可以继承Page实现自己的分页对象)
     * @param gradeId 班级id
     * @return 分页对象
     */
    IPage<Student> findStudentPage(Page<?> page, long gradeId);

xml复制代码<!-- 等同于编写一个普通 list 查询，mybatis-plus 自动替你分页-->
        <select id="findStudentPage" resultType="Student">
            select * from student ,grade g where g.grade_id=#{gradeId}
        </select>

java复制代码/**
     * 分页查询
     * @param page
     * @param gradeId 班级id
     * @return
     */
    IPage<Student> getStudentPage(Page<Student> page,long gradeId);

java复制代码@Override
    public IPage<Student> getStudentPage(Page<Student> page,long gradeId) {
        // 不进行 count sql 优化，解决 MP 无法自动优化 SQL 问题，这时候你需要自己查询 count 部分
        // page.setOptimizeCountSql(false);
        // 当 total 为小于 0 或者设置 setSearchCount(false) 分页插件不会进行 count 查询
        // 要点!! 分页返回的对象与传入的对象是同一个

        return this.baseMapper.findStudentPage(page,gradeId);
    }

java复制代码 /**
     * 分页获取学生详细信息
     *
     * @return
     */
    @GetMapping("listDetailPage")
    public IPage<Student> getStudentDetailPage(PageRequest request) {
        Page<Student> page = new Page<>();
        //设置每页显示几条
        page.setSize(request.getPageSize());
        //设置第几页
        page.setCurrent(request.getPageNum());
        return studentService.getStudentPage(page, 1);
    }

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

import lombok.Data;

import java.io.Serializable;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/28 10:41
 * 分页查询
 */
@Data
public class PageRequest implements Serializable {
    private static final long serialVersionUID = -4869594085374385813L;

    /**
     * 当前页面数据量
     */
    private int pageSize = 10;

    /**
     * 当前页码
     */
    private int pageNum = 1;

    /**
     * 排序字段
     */
    private String field;

    /**
     * 排序规则，asc升序，desc降序
     */
    private String order;
}

xml复制代码 <!--生成器依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.1</version>
</dependency>
  <!--MyBatis-Plus 从 3.0.3 之后移除了代码生成器与模板引擎的默认依赖，需要手动添加相关依赖：-->
<!--添加 模板引擎 依赖，MyBatis-Plus 支持 Velocity（默认）、
Freemarker、Beetl，用户可以选择自己熟悉的模板引擎，
如果都不满足您的要求，可以采用自定义模板引擎。-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.31</version>
</dependency>

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


import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @author kenx
 * @version 1.0
 * @date 2021/6/28 11:31
 * 自动代码生成器
 */
public class MyBatisGeneratorCode {
    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("kenx");
        gc.setOpen(false);
        // gc.setSwagger2(true); 实体属性 Swagger2 注解
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/school?useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        pc.setParent("cn.soboys.springbootmybatisplus.generator");
        mpg.setPackageInfo(pc);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };

        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";

        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/generator/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        /*
        cfg.setFileCreate(new IFileCreate() {
            @Override
            public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
                // 判断自定义文件夹是否需要创建
                checkDir("调用默认方法创建的目录，自定义目录用");
                if (fileType == FileType.MAPPER) {
                    // 已经生成 mapper 文件判断存在，不想重新生成返回 false
                    return !new File(filePath).exists();
                }
                // 允许生成模板文件
                return true;
            }
        });
        */
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();

        // 配置自定义输出模板
        //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
        // templateConfig.setEntity("templates/entity2.java");
        // templateConfig.setService();
        // templateConfig.setController();

        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        //strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        strategy.setEntityLombokModel(true);
        strategy.setRestControllerStyle(true);
        // 公共父类
        //strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
        // 写于父类中的公共字段
        strategy.setSuperEntityColumns("id");
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }
}

pom复制代码<!-- https://mvnrepository.com/artifact/p6spy/p6spy -->
<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.9.0</version>
</dependency>

properties复制代码#url 改为p6spy开头的连接url
spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/school?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&autoReconnect=true
# 驱动名称
# 需要调试拦截打印sql 驱动改为p6spy 拦截
spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver

properties复制代码#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

css复制代码给你一个数组 routes ，表示一系列公交线路，其中每个 routes[i] 表示一条公交线路，第 i 辆公交车将会在上面循环行驶。 


 例如，路线 routes[0] = [1, 5, 7] 表示第 0 辆公交车会一直按序列 1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 
-> ... 这样的车站路线行驶。 


 现在从 source 车站出发（初始时不在公交车上），要前往 target 车站。 期间仅可乘坐公交车。 

 求出 最少乘坐的公交车数量 。如果不可能到达终点车站，返回 -1 。 



 示例 1： 


输入：routes = [[1,2,7],[3,6,7]], source = 1, target = 6
输出：2
解释：最优策略是先乘坐第一辆公交车到达车站 7 , 然后换乘第二辆公交车到车站 6 。 


 示例 2： 


输入：routes = [[7,12],[4,5,15],[6],[15,19],[9,12,13]], source = 15, target = 12
输出：-1




 提示： 


 1 <= routes.length <= 500. 
 1 <= routes[i].length <= 105 
 routes[i] 中的所有值 互不相同 
 sum(routes[i].length) <= 105 
 0 <= routes[i][j] < 106 
 0 <= source, target < 106 

 Related Topics 广度优先搜索 数组 哈希表 
 👍 146 👎 0

java复制代码public int numBusesToDestination(int[][] routes, int source, int target) {

            //确立所有线路的包含关系
            Map<Integer, Set<Integer>> map = new HashMap<>();
            for (int i = 0; i < routes.length; i++) {
                Set<Integer> set = new HashSet<>();
                for (int j = 0; j < routes[i].length; j++) {
                    set.add(routes[i][j]);
                }
                map.put(i, set);
            }

            //存储线路索引
            Deque<Integer> deque = new LinkedList<>();
            //记录到当前站点的线路数量
            Map<Integer, Integer> res = new HashMap<>();
            //确立初始站台
            for (Integer i : map.keySet()) {
                if (map.get(i).contains(source)) {
                    deque.add(i);
                    res.put(i, 1);
                }
            }
            //corner case
            if (deque.isEmpty()){
                return -1;
            }
            if (target==source){
                return 0;
            }
            while (!deque.isEmpty()) {
                int temp = deque.poll();
                int step = res.get(temp);
                for (int i : map.get(temp)) {
                    if (i == target) {
                        return step;
                    }
                    for (int line : map.keySet()) {
                        //包含当前节点的线路全部加入到deque中继续广度优先遍历
                        if (res.containsKey(line)) {
                            continue;
                        }
                        if (map.get(line).contains(i)) {
                            deque.add(line);
                            res.put(line, step + 1);
                        }
                    }

                }
            }
            return -1;

        }

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

java复制代码@SpringBootApplication
public class Chapter55Application {

    private static String CHANNEL = "didispace";

    public static void main(String[] args) {
        SpringApplication.run(Chapter55Application.class, args);
    }

    @RestController
    static class RedisController {

        private RedisTemplate<String, String> redisTemplate;

        public RedisController(RedisTemplate<String, String> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }

        @GetMapping("/publish")
        public void publish(@RequestParam String message) {
            // 发送消息
            redisTemplate.convertAndSend(CHANNEL, message);
        }

    }

}

java复制代码    @Slf4j
    @Service
    static class MessageSubscriber {

        public MessageSubscriber(RedisTemplate redisTemplate) {
            RedisConnection redisConnection = redisTemplate.getConnectionFactory().getConnection();
            redisConnection.subscribe(new MessageListener() {
                @Override
                public void onMessage(Message message, byte[] bytes) {
                    // 收到消息的处理逻辑
                    log.info("Receive message : " + message);
                }
            }, CHANNEL.getBytes(StandardCharsets.UTF_8));

        }

    }

yaml复制代码2021-06-19 16:22:30.935  INFO 34351 --- [ioEventLoop-4-2] .c.Chapter55Application$MessageSubscribe : Receive message : hello

java复制代码public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();
    
    Condition newCondition();
}

csharp复制代码void unlock();

csharp复制代码Condition newCondition();

java复制代码public class Object {
    public final void wait() throws InterruptedException {
        wait(0);
    }
    public final native void wait(long timeout) throws InterruptedException;
    public final void wait(long timeout, int nanos) throws InterruptedException {
        // 这里省略方法的实现
    }
    public final native void notify();
    public final native void notifyAll();
}

java复制代码public interface Condition {
    void await() throws InterruptedException;
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    
    void awaitUninterruptibly();
    boolean awaitUntil(Date deadline) throws InterruptedException;
    
    void signal();
    void signalAll();
}

java复制代码void awaitUninterruptibly();
boolean awaitUntil(Date deadline) throws InterruptedException;

JavaScript复制代码export const CONFIG = {
  URL: 'http://localhost:7777',
  ROLE: {
    0: 'user',
    1: 'admin',
    2: 'superAdmin'
  }
}

JavaScript复制代码import { CONFIG } from '@/consts/config';

export async function login(params) {
  return request(`${CONFIG.URL}/auth/login`, {
    method: 'POST',
    data: params
  })
}

JavaScript复制代码    changeLoginStatus(state, { payload }) {
      // setAuthority(payload.currentAuthority);
      setAuthority(CONFIG.ROLE[payload.user.role]);
      return { ...state, status: payload.code === 0 ? 'ok': 'error', type: payload.type };
    },

python复制代码from flask import Flask
from flask_cors import CORS

from config import Config

pity = Flask(__name__)
CORS(pity, supports_credentials=True)

pity.config.from_object(Config)

sql复制代码SELECT id, age, sex FROM user WHERE age >= 15 AND age <= 23

sql复制代码SELECT age, sex FROM user WHERE age >= 15 AND age <= 18

sql复制代码SELECT id, age, sex FROM user WHERE age >= 15 AND age <= 18

sql复制代码set global innodb_adaptive_hash_index_parts=16;

python复制代码from flask import request, jsonify
from flask_restx import Namespace, Resource

from .model import User

auth = Namespace('auth', '认证管理')

@auth.route('/login')
class Login(Resource):
    def post(self):
        params = request.get_json()
        user = User.get_by_username(params['username'])
        if not check_password_hash(user.password, data['password']):
            raise BusinessException('密码错误')
        return jsonify(user)

python复制代码from flask import Flask

from .encoders import MyJSONEncoder


app = Flask(__name__)
app.json_encoder = MyJSONEncoder

python复制代码from datetime import datetime

from flask.json import JSONEncoder


class MyJSONEncoder(JSONEncoder):
    def default(self, o):
        if isinstance(o, datetime):
            return str(round(o.timestamp()))
        else:
            return super().default(o)

python复制代码from datetime import datetime

from flask.json import JSONEncoder
from flask_sqlalchemy import Pagination


class KoalaJSONEncoder(JSONEncoder):
    def default(self, o):
        if isinstance(o, datetime):
            return str(round(o.timestamp()))
        if isinstance(o, Pagination):
            temp = o.__dict__
            del temp['query']
            temp['pages'] = o.pages
            return temp
        else:
            return super().default(o)

sql复制代码drop table if exists table_name;
create table_name as xxx;

sql复制代码--全量同步一般先delete，然后insert
delete from tmp_a;
insert into tmp_a xxx;
-- 或者直接 insert overwrite
insert overwrite table tmp_a xxx;

sql复制代码create table tmp_a(
    id bigint,
    create_time datetime,
    update_time datetime
);

diff复制代码--    @name p_dwd_rack_machine
--    @description 货架宽表
--    @target rack.dwd_rack_machine

--    @source owo_ods.kylin__machine_release_his
--    @source owo_ods.kylin__machine_device_his

--    @author yuguiyang 2017-12-25
--    @modify