黄泽彬

十分钟完成的操作系统att版本

Sat, 19 Sep 2020 00:00:00 +0000

十分钟完成的操作系统at&t版本-《一个操作系统的实现》

以前看了《一个操作系统的实现》这本书，使用了nasm汇编和bochs虚拟机来编写一个“操作系统”。做了清华大学ucore实验后，我感觉使用at&t汇编和qemu虚拟机来实现一个“操作系统”更加容易调试操作系统，因此改写了成at&t版本。

at&t汇编版本代码如下：

.code16
.section .text
.global _start 
_start:
  movw %cs, %ax
  movw %ax, %ds
  movw %ax, %ss
  call DispStr
loop1:
  jmp loop1

DispStr:
  movw $msg, %ax
  movw %ax, %bp
  movw $16, %cx
  movw $0x1301, %ax
  movw $0x000c, %bx
  movb $0x00, %dl
  int $0x10
  ret
msg:
  .ascii "Hello, OS world!"
  .org 510
  .word 0xAA55

接下来使用as汇编、ld链接：

as -o boot.o boot.s
ld -Ttext=0x7c00 --oformat binary -o boot.bin boot.o

接下来制作一个512KB的虚拟硬盘，将上面生成的“操作系统”写入第一个扇区。

dd if=/dev/zero of=boot.img count=1000
dd if=boot.bin of=boot.img conv=notrunc

接着启动qemu虚拟机，如下，就是模拟插入boot.img硬盘，不需要配置文件，比bochs更方便。

qemu-system-x86_64 -hda boot.img -monitor stdio

成功，如下图：

qemu不用配置文件真的很方便，加上启动参数-S -s就能使用gdb单步调试了。

WSL图形界面

Fri, 18 Sep 2020 00:00:00 +0000

WSL图形界面

我的电脑是windows系统，以前我使用Linux都是跑在virtualbox虚拟机下。后来有了vagrant很容易就能安装Linux虚拟机。所以一直停留在virtualbox阶段。

虽然知道微软Linux子系统WSL，但是一直认为它是阉割版的linux，所以没打算转移到WSL上来。最近学习动手编写操作系统，需要安装qemu虚拟机来调试操作系统，这是完全使用命令行来启动的虚拟机，运行时会弹出一个图形界面。同时vagrant和本地的windows互发文件也不方便，因此就把注意力转移到WSL上来。

WSL真的是和windows配合得天衣无缝，windows下的磁盘都自动挂载到WSL下。有些事WSL不方便做的都可以由windows完成。

再者装上图形界面后，随时想用命令行的linux或图形版的linux都可以。

WSL安装xfce4

WSL安装图形界面的原理是，window上安装图形界面接受服务，WSL安装发送客户端。WSL会把图形界面传送到window的服务上，就能显示图形界面了。

1. 更新软件源

更新软件源，强烈建议更换成阿里云的源，否则国外的源速度下到明年都下载不完。

# 备份list文件
cd /etc/apt
sudo cp source.list source.list.bak
# 管理员权限修改source.list
sudo vim source.list
# 然后在vim中操作替换成阿里云的源
:%s/security.ubuntu/mirrors.aliyun/g
:%s/archive.ubuntu/mirrors.aliyun/g
# 更新软件源
sudo apt update

2. wsl中安装xfce4

sudo apt install xfce4
sudo apt install xfce4-session

安装完后，配置一下

sudo vim ~/.bashrc
# 最后一行添加配置
export DISPLAY=localhost:0

3. window安装VcXsrv

window上下载VcSrv并安装。安装完后启动，按如下填写。

最后桌面会弹出一个大黑框，正常现象，不用管。

4. 在WSL执行命令启动图形界面

xfce4-session --display=localhost:0.0

自此，WSL图形界面搭建结束。

WSL下的terminal很难看，可以试试安装oh-my-zsh试试。

Zookeeper源码调试环境踩坑记录

Mon, 17 Aug 2020 00:00:00 +0000

Zookeeper源码调试环境踩坑记录

1. 下载源码

本文基于zookeeper源码3.6.1版本。

zookeeper的源码在github上，国内下载极慢，还好国内代码托管平台gitee克隆了github上著名的开源项目，从这里下载快多了

2. maven下载jar包

项目clone到idea后，maven开始自动下载依赖的jar包。没想到速度竟然可以这么慢，索性直接改了maven的settings.xml配置，换成阿里云的maven仓库，果然速度蹭蹭蹭一下子下载完毕。

3. 找入口类

zookeeper是一个java项目，启动时有启动脚本，执行命令./zkServer conf/zoo.cfg即可。那么我们可以从这个脚本中找到最终执行的java启动类，为QuarumPeerMain这个主类。另外一种方法可以在zookeeper启动后，执行jps -l则可以看到主类了。

4. 启动报错

知道主类后，我们在idea中配置zookeeper的启动参数。zookeeper启动时需要一个配置文件，我们可以从源码的根目录下的conf文件中zoo_sample.cfg复制一份改名为zoo.cfg。然后启动main方法。

发现报如下错误：

log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
Exception in thread "main" java.lang.NoClassDefFoundError: com/codahale/metrics/Reservoir
	at org.apache.zookeeper.metrics.impl.DefaultMetricsProvider$DefaultMetricsContext.lambda$getSummary$2(DefaultMetricsProvider.java:126)
	at java.base/java.util.concurrent.ConcurrentHashMap.computeIfAbsent(ConcurrentHashMap.java:1705)
	at org.apache.zookeeper.metrics.impl.DefaultMetricsProvider$DefaultMetricsContext.getSummary(DefaultMetricsProvider.java:122)
	at org.apache.zookeeper.server.ServerMetrics.<init>(ServerMetrics.java:74)
	at org.apache.zookeeper.server.ServerMetrics.<clinit>(ServerMetrics.java:44)
	at org.apache.zookeeper.server.ZooKeeperServerMain.runFromConfig(ZooKeeperServerMain.java:132)
	at org.apache.zookeeper.server.ZooKeeperServerMain.initializeAndRun(ZooKeeperServerMain.java:112)
	at org.apache.zookeeper.server.ZooKeeperServerMain.main(ZooKeeperServerMain.java:67)
	at org.apache.zookeeper.server.quorum.QuorumPeerMain.initializeAndRun(QuorumPeerMain.java:140)
	at org.apache.zookeeper.server.quorum.QuorumPeerMain.main(QuorumPeerMain.java:90)
Caused by: java.lang.ClassNotFoundException: com.codahale.metrics.Reservoir
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:581)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
	... 10 more

Process finished with exit code 1

冒失缺失了一个类，导入对应的maven坐标还是无法解决。最后找到一种方法，将该main方法放到test类下面即可。如QuarumPeerMainTest。将QuarumPeerMain的main方法复制到QuarumPeerMainTest类中。再次启动即可。

以上，忙了大半天。

Netty源码服务器启动流程

Sat, 15 Aug 2020 00:00:00 +0000

Netty源码服务器启动流程

看到这篇文章的应该都用过Netty吧。Netty服务端的模板代码如下，我们分析下它是怎么启动的。不要纠结没有关闭连接的代码，毕竟我们只是用这段代码来debug。这篇文章我主要写的是Netty服务端的启动流程。

读完这篇文章你会知道：

Netty的几大组件的关系是什么？包括NioEventLoopGoup, NioEventLoop, Channle, ChannelHandler, Pipeline
Netty是怎么注册感兴趣的事件的？
Netty服务的bossGroup收到连接后，是怎么转派到workerGroup的。
Netty服务端启动时经历了什么？

package netty.simple;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 28)
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .childHandler(new ChannelInitializer<SocketChannel>() {

                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new MyChatHandler());
                    }
                });
        ChannelFuture sync = bootstrap.bind(6666).sync();
        sync.channel().closeFuture().sync();
    }
}

EventLoopGroup事件循环组

Netty是基于Reactor事件模型的，它将通道的连接和处理分开，bossGroup负责处理NioServerSocketChannel通道连接，通道连接后生产NioSocketChannel分派到workerGroup处理通道的读写事件和业务逻辑。具体怎么通道怎么分配的，接下来再说明。

EventLoopGroup顾名思义，它就是EventLoop组，维护一堆EventLoop的，如下图(NioEventGroup实现了EventExcutor接口)。默认new EventLoopGroup()会生成(cpu核心数*2)个EventLoop，每个EventLoop绑定一个端口，所以如果服务只绑定一个端口的话，就指定为1个接口，即new EventLoopGroup(1);

NioEventLoop事件循环

每个EventLoop都有一个死循环，负责监听Channel上的事件。看NioEventLoop的继承链，它是一个EventExecutor、EventLoop，所以NioEventLoop是一个线程池。NioEventLoop的父类SingleThreadEventExecutor维护了一个线程池对象。

NioEventLoop的execute(Runable r)方法，这是线程次的提交方法，当提交一个线程到NioEventLoop中时，就是执行这个方法，它做的工作如下图，是将提交过来的线程task入队，然后执行NioEventLoop的线程提交方法execute，先将task入队，再看情况执行startThread()。

跟踪进去，它会执行doStartThread()方法。这个方法提交一个线程，立马执行了SingleThreadEventExecutor.this.run()方法。这里，虽然NioEventLoop没有继承Thread或者实现Runnable接口，不能认为它是一个线程实现类。但是它有自己的run()方法，并且初次启动NioEventLoop时会执行SingleThreadEventExecutor.this.run()方法，因此暂且可以认为它是一个线程吧。

那NioEventLoop这个名义上的线程它的run方法是什么呢，如下图，他就是一个死循环了。说到这里，就知道问什么我们说NioEventLoop是一个死循环的线程了吧。

Channel通道

再看到ChannelFuture f = b.bind(PORT).sync();这一句的bind方法，它做了初始化和注册通道的任务。即ServerBootstrap初始化了注册了通道。

他会根据.channel(NioServerSocketChannel.class)这句代码生成一个服务端的NioServerSocketChannel。

Channel初始化时，会给Channel塞很多东西，比如感兴趣的OP_ACCEPT事件，和非阻塞的配置，看到这里就明白了Netty底层还是NIO，Netty其实就是对NIO的封装了。

还向该Channel的pipeline中加入了一个Channel初始化器ChannelInitializer，那么ChannelInitializer的initChannel什么时候执行呢？先剧透一下，这个方法在Channel注册完成后执行，现在还在Channel初始化阶段，还没执行。

Pipeline管道

写过Netty小demo的都知道，我们需要处理自己的业务逻辑时都是向Channel对应的pipeline中加入我们的ChannelHandler。这里就讲一下围绕Channel的组件吧。

如下图，每一个Channel都有自己所属的EventLoop和Pipeline。

pipeline维护了链表形式的ChannelHandlerContext，每次addLast()添加ChannelHandler到pipeline中时，都会被转成ChannelHandlerContext并添加一个链表节点

register注册

Channel初始化完成之后，会执行到注册阶段，如下代码，它提交了一个任务给到EventLoop，上面的分析我们知道，提交EventLoop.execute后，会先将task入队，然后启动死循环执行task，这里是register0方法。

那么register0就是异步通过EventLoop执行的了。main线程继续执行，我们断点在了NioEventLoop的线程，切换过去可以发现它启动了死循环。

调到底层进行注册了。

接下来看到没有，它要执行ChannelInitilizer的initChannel方法了。

它是怎么执行的呢，如下图，调用的是pipeline的execute方法。

跟踪进去，开始执行方法了。

跳到我们最初的initChannel方法。可以看到最后提交了一个task到EventLoop中。往pipeline中添加了一个ServerBootstrapAcceptor。bossGroup是怎么实现将连接建立后分配给workGroup的呢，这就是关键。

SocketChannel连接分配

我们知道，如果有客户端连接到服务端的话，会依次执行pipeline中的ChannelHandler，上面我们可以看到，NioServerSocketChannle最后一个ChannelHandler就是ServerBootstrapAcceptor连接分配器。

我们用客户端连接上来，发现它执行到了ServerBootstrapAcceptor的channelRead方法。并拿到一个SockerChannel，向SocketChannel添加了ChannelInitializer。然后向childGroup中注册该SocketChannel。

ChildGroup会选择一个EventLoop来注册这个SocketChannel。

至此，Netty服务端启动流程结束。

轻松理解Shiro与实战

Tue, 11 Aug 2020 00:00:00 +0000

轻松理解Shiro与实战

后端管理系统登录一般都涉及到权限控制，权限管理组件用的最多的就是Apache的Shiro了，任何系统的登录模块，基本都可以使用shiro来实现我们的功能。相信看到这篇文章的肯定知道了Shiro的作用，废话不多说，直入主题吧。

Spring Boot整合Shiro

首先来思考一下正常需要权限控制的网站它的登录流程是什么样的？大概流程如下。

设置页面拦截。系统中有些页面可以直接访问，有些页面需要登录才能访问，有些页面不仅需要登录还需要登录的用户有相关权限才能访问，这是第一步。
如果用户没登录直接访问需要登录或需要权限的页面，则调转到登录页面让用户登录
用户登录认证后，访问需要权限的页面时，系统可以识别该用户是谁并鉴权。

Shiro说到底就是按上面步骤解决问题的，我们要做的仅仅是：配置拦截页和权限接口、实现认证业务逻辑、实现鉴权业务逻辑。

表设计

用户权限模块一般涉及到五张表，基本的三张表 + 两张关联表：(用户表base_user, 角色表base_role, 资源表base_resource) + (用户角色关联表base_user_role, 角色资源关联表base_role_resource)，以下说说表结构。

用户表base_user

主要是用户名和密码两个字段，用来登录认证。

角色表

系统中所有的角色

资源表

系统中所有的资源包括菜单和按钮等，都需要权限控制。其中code代表了资源代号，其实也可以用表中的no代替用于控制权限，不过用自定义的code比较直观，比如添加文章按钮的权限可以设置为article:add

用户角色表

每个用户对应多个角色，一个角色可以对应多个用户，权限资源是赋予角色的。

角色资源表

多对多的关系。

脚本整理

以上五个表的脚本(postgresql)

-- 用户表
create table base_user (
	id bigserial,
	no int8 not null default 0,
	name varchar(255) not null default '',
	password varchar(255) not null default '',
	nickname varchar(255) not null default '',
	create_time timestamp not null default current_timestamp,
	create_user varchar(64) not null default '',
	update_time timestamp not null default current_timestamp,
	update_user varchar(64) not null default current_timestamp,
	constraint "base_user_primary_key" primary key (id)
);
comment on table base_user is '用户表';
comment on column base_user.id is '物理自增主键';
comment on column base_user.no is '业务主键';
comment on column base_user.name is '用户名';
comment on column base_user.password is '密码';
comment on column base_user.nickname is '昵称';
comment on column base_user.create_time is '创建时间';
comment on column base_user.create_user is '创建人编号';
comment on column base_user.update_time is '修改时间';
comment on column base_user.update_user is '修改人编号';
-- 角色表
create table base_role (
	id bigserial,
	no int8 not null default 0,
	name varchar(255) not null default '',
	create_time timestamp not null default current_timestamp,
	create_user varchar(64) not null default '',
	update_time timestamp not null default current_timestamp,
	update_user varchar(64) not null default current_timestamp,
	constraint "base_role_primary_key" primary key (id)
);
comment on table base_role is '角色表';
comment on column base_role.id is '物理自增主键';
comment on column base_role.no is '业务主键';
comment on column base_role.name is '角色名';
comment on column base_role.create_time is '创建时间';
comment on column base_role.create_user is '创建人编号';
comment on column base_role.update_time is '修改时间';
comment on column base_role.update_user is '修改人编号';
-- 资源表
create table base_resource (
	id bigserial,
	no int8 not null default 0,
	name varchar(255) not null default '',
	code varchar(64) not null default '',
	type int2 not null default 0,
	parent_no int8 not null default 0,
	create_time timestamp not null default current_timestamp,
	create_user varchar(64) not null default '',
	update_time timestamp not null default current_timestamp,
	update_user varchar(64) not null default current_timestamp,
	constraint "base_resource_primary_key" primary key (id)
);
comment on table base_resource is '资源表';
comment on column base_resource.id is '物理自增主键';
comment on column base_resource.no is '业务主键';
comment on column base_resource.name is '资源名';
comment on column base_resource.code is '资源代号，用于@RequiresPermissions';
comment on column base_resource.type is '资源类型，0菜单 1按钮';
comment on column base_resource.parent_no is '父元素编号';
comment on column base_resource.create_time is '创建时间';
comment on column base_resource.create_user is '创建人编号';
comment on column base_resource.update_time is '修改时间';
comment on column base_resource.update_user is '修改人编号';
-- 角色权限表
create table base_user_role (
	id bigserial,
	no int8 not null default 0,
	user_no int8 not null default 0,
	role_no int8 not null default 0,
	create_time timestamp not null default current_timestamp,
	create_user varchar(64) not null default '',
	update_time timestamp not null default current_timestamp,
	update_user varchar(64) not null default current_timestamp,
	constraint "base_user_role_primary_key" primary key (id)
);
comment on table base_user_role is '用户角色表';
comment on column base_user_role.id is '物理自增主键';
comment on column base_user_role.no is '业务主键';
comment on column base_user_role.user_no is '用户编号';
comment on column base_user_role.role_no is '角色编号';
comment on column base_user_role.create_time is '创建时间';
comment on column base_user_role.create_user is '创建人编号';
comment on column base_user_role.update_time is '修改时间';
comment on column base_user_role.update_user is '修改人编号';
-- 角色资源表
create table base_role_resource (
	id bigserial,
	no int8 not null default 0,
	role_no int8 not null default 0,
	resource_no int8 not null default 0,
	create_time timestamp not null default current_timestamp,
	create_user varchar(64) not null default '',
	update_time timestamp not null default current_timestamp,
	update_user varchar(64) not null default current_timestamp,
	constraint "base_role_resource_primary_key" primary key (id)
);
comment on table base_role_resource is '用户角色表';
comment on column base_role_resource.id is '物理自增主键';
comment on column base_role_resource.no is '业务主键';
comment on column base_role_resource.role_no is '角色编号';
comment on column base_role_resource.resource_no is '资源编号';
comment on column base_role_resource.create_time is '创建时间';
comment on column base_role_resource.create_user is '创建人编号';
comment on column base_role_resource.update_time is '修改时间';
comment on column base_role_resource.update_user is '修改人编号';

导入shiro-spring-boot-web-starter

maven中导入如下Shiro的坐标。

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-web-starter</artifactId>
    <version>1.5.1</version>
</dependency>

拦截所有页面

步骤都在下面代码的注释了，总结一句话就是：通过ShiroFilterFactoryBean配置拦截的页面，拦截后调转到登录页，登录过程中，SecurityManager调用Realm来获取认证、授权的信息。

package io.github.zebinh.zmall.mall.admin.config;

import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Shiro配置类
 */
@Configuration
public class ShiroConfig {


    /**
     *  Shiro自带的过滤器，可以在这里配置拦截页面
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(@Autowired DefaultWebSecurityManager securityManager){

        // 1. 初始化一个ShiroFilter工程类
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        // 2. 我们知道Shiro是通过SecurityManager来管理整个认证和授权流程的，这个SecurityManager可以在下面初始化
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        // 3. 上面我们讲过，有的页面不需登录任何人可以直接访问，有的需要登录才能访问，有的不仅要登录还需要相关权限才能访问
        Map<String, String> filterMap = new LinkedHashMap<>();

        // 4. Shiro过滤器常用的有如下几种
        // 4.1. anon 任何人都能访问，如登录页面
        filterMap.put("/api/user/login", "anon");
        // 4.2. authc 需要登录才能访问，如系统内的全体通知页面
        filterMap.put("/api/user/notics", "authc");
        // 4.3. roles需要相应的角色才能访问，当然可以改为在需要权限的接口上加注解@RequiresRoles(value = {"admin","manager","writer"}, logical = Logical.OR)或者@RequiresPermissions("article:add")
        // filterMap.put("/api/user/getUser", "roles[admin]");
        // 5. 让ShiroFilter按这个规则拦截
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

        // 6. 用户没登录被拦截后，当然需要调转到登录页了，这里配置登录页
        shiroFilterFactoryBean.setLoginUrl("/api/user/login");
        return shiroFilterFactoryBean;
    }

    /**
     * SecurityManager管理认证、授权整个流程
     */
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(@Autowired UserRealm userRealm){

        // 7. 新建一个SecurityManager供ShiroFilterFactoryBean使用
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 8. SecurityManager既然管理认证等信息，那他就需要一个类来帮他查数据库吧。这就是Realm类
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    /**
     * 自定义Realm，当SecurityBean需要来查询相关权限信息时，需要有Realm代劳
     */
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }


    /**
     * 为了方便观看，我将UserRealm类的实现写在这里了
     */
    class UserRealm extends AuthorizingRealm {

        // 9. 前面被authc拦截后，需要认证，SecurityBean会调用这里进行认证
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
            System.out.println("执行认证逻辑");
            UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;

            // 9.1. 为了方便演示，我这里写死了用户admin-name密码admin-pwd才能登录
            if (token.getUsername() == null || !token.getUsername().equals("admin-name")){
                return null;
            }

            return new SimpleAuthenticationInfo("", "admin-pwd", "");
        }

        // 10. 前面被roles拦截后，需要授权才能登录，SecurityManager需要调用这里进行权限查询
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            System.out.println("执行授权逻辑");

            // 10.1. 为了方便演示，这里直接写死返回了admin角色，所有能登录的角色都是admin了
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            info.addRole("admin");
            return info;
        }
    }

}

调转到登录页后，用户登录，直接调用Subject类的login方法即可，Subject类会调用SecurityManager进行认证。看到这里，应该就能理解本文开头的两幅图了吧。

package io.github.zebinh.zmall.mall.admin.user.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

@RestController
@RequestMapping("api/user")
public class UserController {

    @PostMapping("login")
    public String login(@RequestBody Map<String, String> user){

        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(user.get("username"), user.get("password"));

        try{
            subject.login(token);
        }catch (UnknownAccountException e){
            System.out.println("用户名不存在");
            return "用户名不存在";
        }catch (AuthenticationException e) {
            System.out.println("认证失败");
            return "认证失败";
        }
        return "登录成功";
    }
    
    @GetMapping("getUser")
    public Object getUser() {
        return SecurityUtils.getSubject();
    }

    @RequiresPermissions("article:add")
    @GetMapping("notics")
    public String notics(){
        return "通知";
    }
}

前后端分离按钮显示

前后端分离时，后端可以提供一个查询用户权限的接口，前端如果是vue，可以使用v-if判断该用户使用有权限再显示，如：v-if=”hasPermission(‘acticle:add’)”

Shiro如何识别用户

在登录完成后，shiro会发一个cookie给客户端，包含了sessionId，因此能识别当前用户，当访问需要登录的页面时，如发现cookie中有sessionId，判断该用户已登录，则不需要调用Realm再进行认证了。cookie如下所示。

那么问题来了，cookie只有pc端才有，移动端并没有cookie，该怎么解决移动端的shiro认证问题呢，同时这种方式无法解决单点登录的问题，应为cookie只能在同源的网站被发送到服务器。

解决方案就是，这时候就要定义自己的Session管理器了。用户登录后，自定义Session管理器生成session并生成一个token给到前端，前端每次访问都传递token，shiro会调用自定义的Session管理器做校验。Session中可以放置当前登录用户的信息并放置在redis中。自定义的Session管理器每次从redis中读取数据即可。

写给后端的前端快速搭建笔记

Mon, 10 Aug 2020 00:00:00 +0000

写给后端的前端快速搭建笔记

迫于平时学习了前端之后没有形成体系，并且我是做后端的，没打前端的代码会生疏，下次又不知道怎么搭建前端框架了。因此这里记录一个前端的搭建过程，并写一个能用就行的前端界面。这里按照前端工程化的搭建流程来梳理技术栈，以Vue + ElementUI为例。

NodeJS：NodeJS是前端工程化的重要支柱，他使得JS脱离了浏览器环境，使得JS可以像脚本一样在主机上运行。
npm：NPM是随NodeJS安装的包管理工具，类似后端的Maven，使用npm install命令可以安装当前目录下package.json需要的包，本地按照时存放在当前目录./node_modules目录，全局安装则安装nodejs的安装目录，按照NodeJS语法，可以使用require()引入NodeJs包。使用命令npm run dev可以运行package.json中scripts节点下的dev节点对应的命令，比如
```
{
// ...
"scripts": {
  "build": "node build.js"
}
}
```

使用npm run build就是执行命令node build.js。

同时开过程中使用npm install xxx –save中save选项表示会讲这个模块写入package.json带上生产，而–save-dev则只在开发环境。

npm下载过慢，建议使用cnpm

npm install -g cnpm --registry=https://registry.npm.taobao.org

创建项目

安装完NodeJS和npm后，就可以创建项目了。使用vue-cli脚手架来创建工程比较简单，所以先安装Vue脚手架吧。

npm install --global vue-cli

安装完后，输入vue命令看看是否安装成功。

接着使用安装完的vue脚手架，执行如下命令生成项目。

vue init webpack myproject

之后，执行npm install和npm run dev，安装必要的包和启动vue项目。

安装element-ui库并将其带上生产。

npm install element-ui --save

开始开发

导入文件进行显示

Vue每个文件都是一个组件，文件结构为：

<template>
</template>
<script>
</script>
<style>
</style>

文件融合了html、css、js，是一个完整的组件文件。因此开始写页面时，你可以在components目录下新建一个vue文件，然后在首页导入看到效果。其实component只是一段代码，注册到vue中即可使用。前提是你将文件导入进来。

想注册一个组件
导入组件
在template中使用

<template>
    <div>
        <Test></Test>
    </div>
</template>
<script>
    import Test from './components/test.vue'
    export default {
        components: {
            Test
        }
    }
</script>

项目根目录下的src/main.js是程序入口，通用的组件可以在这里注册。比如element-ui组件。

import ElementUI from 'element-ui' //element-ui的全部组件
import 'element-ui/lib/theme-chalk/index.css'//element-ui的css
Vue.use(ElementUI) //使用elementUI

上面的通过在template中使用引用组件，比较low了。不如用router前端路由来实现。

先导出Test组件。

<script>
  export default {
    name: "Test",
    data() {
      return {
        activeIndex: '1',
        activeIndex2: '1'
      };
    },
    methods: {
      handleSelect(key, keyPath) {
        console.log(key, keyPath);
      }
    }
  }
</script>

在App.vue中放置一个路由占位符。

<template>
  <div id="app">
    <router-view/>
  </div>
</template>

然后在router/index.js中导入并配置它。

import Vue from 'vue'
import Router from 'vue-router'
import HelloWorld from '@/components/HelloWorld'
import Test from '@/components/test.vue'

Vue.use(Router)

export default new Router({
  routes: [
    {
      path: '/',
      name: 'HelloWorld',
      component: HelloWorld
    },
    {
      path: '/test',
      name: 'Test',
      component: Test
    }
  ]
})

页面布局

到了上面这一步，你就可以自定义添加自己喜欢的页面了。写前端最麻烦的就是布局，所以这里讲一下布局的使用。现在的布局主要使用flex弹性布局。

首先在外层div（以下称为容器）使用display: flex，其下的子元素默认会变为行内块元素，可以定义大小。如果想定义宽度是整个屏幕占比多少，可以使用width: 33vx，视口被均分为100份，取33份。布局一般宽度用占比，高度定死。

容器中有主轴和侧轴之分。默认主轴是横向的，侧轴是纵向的。子元素的排列就是通过调整主轴侧轴来实现的。

如果想改变主轴的方向，可以使用flex-direction: column设置主轴为垂直方向。

如果想调整主轴元素的间隔布局，可以使用justify-content

center：在主轴居中对齐
space-around: 平分剩余空间
sapce-between：两端对齐，再平分剩余空间

如果主轴元素过多，会导致元素被挤压在主轴上，可以使用flex-wrap: wrap让元素换行。

如果想让元素垂直居中，则需要调整侧轴的布局。align-items设置侧轴布局，适用于单行。

center：居中
stretch：拉伸，拉伸时子元素不能设置高度

当上面元素是多行的，则align-items不起作用。我们可以使用align-content来调整多行间的间距和布局。

center: 居中
space-around: 平分剩余空间
sapce-between：两端对齐，再平分剩余空间

上面都是容器的属性，接下来介绍一些子元素的属性。

如果你子元素有三个，前两个设置了宽度，想让第三个占所有剩下的宽度，可以使用flex属性。

element-ui的布局建议看视频：https://www.bilibili.com/video/BV1NK4y187XH?p=5

vue-router的路由视图只能获取到顶层路由，即#App下的路由器，然后push进去路由地址，如果是嵌套路由，有点麻烦。

前端调用后台的接口可以使用axios模块，先安装再导入。

# 安装
npm install axios

# 导入并使用
import axios from 'axios'
Vue.prototype.$axios = axios

使用方法：

this.$axios
      .get("https://www.v2ex.com/api/topics/hot.json")
      .then(function(res){
        console.info(res);
      })
      .catch(function(err){
        console.info(err)
      })

上面会出现跨域报错，需要使用nginx反向代理解决。

从RocketMQ源码了解其系统设计

Sun, 02 Aug 2020 00:00:00 +0000

从RocketMQ源码了解其系统设计

文章写作时间：2020年7月30日 07点50分

本篇文章RocketMQ代码基于最新的源码：rocketmq-all-4.7.1。

工作中经常用到RocketMQ，只知道使用却不知道他的原理，有时候排查问题都不知从何处下手。所以最近研究了一下RocketMQ的源码，了解其系统设计，使用起来也得心应手了。

读了这篇文章，你会了解到RockeMQ的架构和解决RocketMQ以下疑问。

RocketMQ消费者消费失败后为什么会重试？
RocketMQ延时队列的原理？
RocketMQ如何将一条消息同时发送给外部的A、B系统？
内网环境如何避免其他同事的机器抢你的MQ消息？
RocketMQ消息进度如何保存？

以上是我画的RocketMQ的系统设计图。本来想用Excel画一个，嫌画起来麻烦就用apple pencil画一个，将就着看吧，主要看我接下来文字的讲解。

消息发送总流程

如果只是想了解RocketQM的消息发送和消费流程的话，阅读这部分的文字就够了。下面文字讲讲上面图的流程。

RocketMQ有四个概念模型，RocketMQ中间件启动时，首先启动NameServer，NameServer维护了Broker的信息，它接收Broker的心跳，Broker每隔30s会想NameServer发送心跳。NameServer并每10s扫描一下存活Broker，如果超过120s没有收到Broker的心跳，则认为该Broker宕机，将Broker的信息移除。

Broker消息代理服务器，他是保存和转发消息的服务器。Broker启动时，每隔30s向NameServer发送心跳。并且接收生产者和消费者的请求。消息存储在Broker中，Broker接收到消息后都将其写入commitlog目录中，并写入到指定的队列，队列在Broker中的组织形式是consumerqueue目录下的topic名字命名的目录，每个队列以0、1、2、3数字命名。写入到commitlog后会将该消息的offset转发到consumerqueue中，消费者才能从队列中拉取消息。

生产者启动时每隔30s向NameServer更新topic路由信息。生产者发送消息时，先在本地缓存中查找他要发送的topic在哪个Broker，如果找不到则请求NameServer查找。找到Topic路由和Topic下有几个队列后，生产者选择该topic下的一个队列，将消息发送到该队列。这里还涉及到故障规避算法，这里不讲解。

RocketMQ的消费者获取消息的方式有推模式和拉模式。推模式其实就是客户端封装的拉模式，本质上RocketMQ只有一种拉模式。消费者会根据自身的负载均衡算法，选择本消费者需要消费的队列。请求Broker获取该队列的信息，默认32条消息。将消息拉取下来后，会将消息提交到线程池进行消费，默认10个线程。如果消费失败，会将消息发回Broker失败重试机制，并推进内存中的进度。如果成功则直接推进进度，消费者每隔10s会将消费进度发送到Broker保存。

如果消费失败，Broker会将消息投递到延时队列中，所以RocketMQ的失败重试机制是基于延时队列的。RocketMQ只支持特定延时等级的延时队列，不支持自定义延时时间。每个延时队列，都有一个定时器每100ms查询该消息是否到时间了。是的话则将消息发送给对应的队列。

RocketMQ模型概念

如上图，RocketMQ主要涉及4个角色：

NameServer：命名服务器，更新和发现Broker服务
Broker：消息中转角色，负责存储、转发消息
Producer：生产者
Consumer：消费者

RocketMQ路由中心NameServer

NameServer主要提供服务发现和注册功能，是一个无状态节点，可集群部署，集群间的机器不交流。

源码中，NameServer启动类为NamesrvStartup，启动时它每10s扫描一个存活的broker(非存活会移除)，并启动Netty处理网络请求

NameServer路由注册和故障剔除

NameServer用了4个Map来维护Topic路由信息。

他们的运行时结构如下：

topicQueueTable：Topic队列表，记录每个Topic下有多少个队列，在哪个Broker上，消息消费是基于队列的。
brokerAddrTable：Broker地址表，记录Broker在哪个集群，Broker的主从地址。
clusterAddrTable：集群信息表，记录了集群下所有的Broker
brokerLiveTable：broker存活信息表，记录了broker上次心跳时间，超过120s表示broker宕机，移除该broker

Broker心跳

broker每10秒发送心跳。

路由发现

RockeMQ路由发现是非实时的，当Topic路由出现变化后，NameServer不会主动推送给客户端(生产者、消费者)，而是由客户端定时拉取主题最新的路由。

RocketMQ消息发送

RocketMQ支持3种消息发送方式：

同步
异步
单向

主要了解的两个问题：

消息队列如何进行负载？
消息发送如何实现高可用？

Producer启动

Producer启动时，会获取一个MQClientInstance客户端，用于和服务端交互。

同一个JVM中只有一个MQClientInstance，不管有多少生产者或者消费者。路由信息由MQClientInstance维护，所以生产者和消费者使用的是同一份路由。

查找主题路由信息

本地缓存中没有Topic的路由，则实时向NameServer拉取。拉取不到，如果配置了自动创建Topic，则自动创建。

Topic在Broker上的存在形式是一个目录，队列MessageQueue才是存储的实体。消息的发送和接收都基于队列。

选择消息队列

选择一个队列，向这个队列发送消息。默认的负载均衡方式就是每次队列序号+1

如果开启了故障规避，发送给某个Broker失败，则会规避一定的时间。所以高可用的方式就是重试与规避。

RocketMQ消息存储

RocketMQ消息存储主要有三个文件：

commitlog：所有消息发送过来都会落到这个文件中
consumerqueue：这个目录下是很多以topic命名的目录，每个topic下有多个队列目录，每个队列下有多个文件。消息落到commitlog后会异步转发到这个目录中。消息的消费以这个目录为主
index：提供了以tag快速查询消息的索引文件

consumerqueue和index中查到的只是消息的偏移量，查到偏移量之后再到commitlog中查整个消息的信息。类似mysql的B+树索引，根据普通索引找到的是主键id，再根据主键id回表查询记录。存储文件这么设计使得写入commitlog时是顺序写，提高了效率。

commitlog中每个文件1G大小，使用了系统调用mmap()内存映射文件技术。

示例图

消息id(msgId)的生成方式如下，所以可以通过msgId快速从commitlog中找到消息。

RocketMQ相关文件

consumerOffset.json存储了集群消费模式消息消费的进度，以消费组的形式存在，如果删除了这个文件，可以设置消费组默认从commitlog的头或者尾开始重新消费。

consumerqueue消息队列文件中存储的结构如下，最后的tagcode在消费者拉取消息时起到了过滤的作用。

消息存到了consumerqueue队列中时，如果开启了长轮询，会实时将消息返回给消费者。

过期文件定期删除

默认保留3天

RocketMQ消息消费

消息消费以组的模式开展，一个消费组内可以包含多个消费者，每一个消费组可订阅多个主题，消费组之间有集群模式与广播模式两种消费模式。集群模式，主题下的同一条消息只允许被其中一个消费者消费。广播模式，主题下的同一条消息将被集群内的所有消费者消费。消息服务器与消费者之间的消息传送也有两种方式：推模式、拉模式。所谓的拉模式，是消费端主动发起拉消息请求，而推模式是消息到达消息服务器后，推送给消息消费者。RocketMQ消息推模式的实现基于拉模式，在拉模式上包装一层，一个拉取任务完成后开始下个拉取任务。

消费者启动

消息消费者启动时会订阅指定的主题和重试主题。

由RebalanceImpl进行负载，就是将主题下对应的队列分配给不同的消费者拉取。

查出所有队列，进行负载分配。有多种负载均衡算法。负载会定时执行，如果新增加了消费者则会将该消费者加入负载均衡中。如果消费者个数大于队列数，多出来的消费者将不参与消息消费。

拉取消息

分配好负载后，每个消费者都分配到了指定的队列。开始拉取消息，并提交到线程池消费。每次默认拉取32条消息。为提高效率，消息拉取采用长轮询机制。

消费模式有并发消费和顺序消费。

开始消费消息，执行业务逻辑。默认10个线程，最大20个线程。

消费失败，将消息发回Broker，失败重试。推进消费进度。

消费失败设置delayLevel

定时消息机制

每个定时消息队列有一个定时器，定时器的任务就是遍历定时队列，将时间到了的消息封装成指定的topic写回commitlog。间隔100ms后定时器重新扫描定时队列。

定时消息图：

消息重试机制

定时消息时通过设置delayLevel声明，消息消费失败时，也设置了delayLevel，所以消息重试机制是基于定时消息的。每次delayLevel加一，如果失败超过16次，则不会重试，投递到死信队列。

服务端处理消息拉取

服务端会以tagcode先过滤一遍。

docker安装部署rocketmq和SpringBoot小实例

Sat, 18 Jul 2020 00:00:00 +0000

docker安装部署rocketmq和SpringBoot小实例

rocketmq模型如上图所示，分为如下几个部分：

NameServer：主要用作注册中心，用于管理Topic信息和路由信息的管理
Broker：负责存储、消息tag过滤和转发。需将自身信息上报给注册中心NameServer
Producer：生产者
Consumer：消费者

由上各部分角色的功能可知，我们需要先安装启动NameServer，再启动Broker即可搭建完RocketMQ

1. 部署NameServer

首先下载镜像：

docker pull rocketmqinc/rocketmq:4.4.0

启动NameServer，暴露9876端口

docker run --name rmqnamesrv -d -p 9876:9876 rocketmqinc/rocketmq:4.4.0 sh mqnamesrv

启动完成后，可以curl 9876端口测试服务是否启动成功

2. 部署Broker

RocketMQ是Java编写的程序，Broker和NameServer都在上面的镜像中，只是启动命令不同而已。

启动Broker

docker run --name rmqbroker -d -p 10911:10911 -p 10909:10909  --link rmqnamesrv:namesrv -e "NAMESRV_ADDR=namesrv:9876" rocketmqinc/rocketmq:4.4.0 sh mqbroker

–link 将NameServer容器起个别名，Broker中需要配置一个NAMESRV_ADDR参数指向NameServer地址。

同上，这里也可以使用curl localhost:10911验证下服务器是否启动

3. 部署RocketMQ可视化界面控制台

这一个步骤不做也可以通过Java等客户端访问到RocketMQ了，不过有可视化界面便于观察RocketMQ数据。不需要的可以跳过这一步

下载镜像：

docker pull pangliang/rocketmq-console-ng

启动容器：

docker run --name rmqconsole -d -p 8080:8080 --link rmqnamesrv:namesrv -e "JAVA_OPTS=-Drocketmq.namesrv.addr=namesrv:9876"  pangliang/rocketmq-console-ng

自此，也可以使用curl命令测试控制台界面是否成功启动。curl localhost:8080，如下表示启动成功。

宿主机也可以登录访问控制台界面。

4. SpringBoot整合RocketMQ小实例

maven中先导入apache官方提供的starter

<!-- https://mvnrepository.com/artifact/org.apache.rocketmq/rocketmq-spring-boot-starter -->
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.1.0</version>
</dependency>

application.yml配置一个name-server地址，具体值看你的机器。

这里也可以通过accessKey和secureKey登录连接。默认配置在RocketMQ的配置文件中，默认值是：

accessKey: RocketMQ
secureKey: 12345678

生产者发送消息：

@RestController
public class RocketController {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    // 发送给Broker，默认会自动创建topic，topic和tag用冒号分隔
    @GetMapping("/rocket/send")
    public String rocketSend() {
        LocalDateTime currentTime = LocalDateTime.now();
        rocketMQTemplate.convertAndSend("rocket-topic-1", currentTime.toString());
        return currentTime.toString();
    }

    // 延时消息，RocketMQ支持这几个级别的延时消息，不能自定义时长
    // 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
    @GetMapping("/rocket/delayMsg/send")
    public String rocketDelayMsgSend() {
        LocalDateTime currentTime = LocalDateTime.now();
        rocketMQTemplate.syncSend("rocket-topic-1:tag-2", MessageBuilder.withPayload(currentTime.toString()).build(), 2000, 3);
        return currentTime.toString();
    }
}

消费者：

@Component
@Slf4j
public class RokcetServiceListener {

    @Service
    @RocketMQMessageListener(consumerGroup = "consumer-group-1", topic = "rocket-topic-1")
    public class Consumer1 implements RocketMQListener<String> {

        @Override
        public void onMessage(String s) {
            log.info("consumer1 rocket收到消息：{}", s);
        }
    }

    // RocketMQ支持两种消费方式，集器消费和广播消费
    @Service
    @RocketMQMessageListener(consumerGroup = "consumer-group-2", topic = "rocket-topic-1",
            selectorExpression = "tag2", messageModel = MessageModel.BROADCASTING)
    public class Consumer2 implements RocketMQListener<String> {
        @Override
        public void onMessage(String s) {
            log.info("consumer2 rocket收到消息：{}", s);
        }
    }
}

优雅地使用SpringBoot注解写代码 SpringBoot常用注解

Wed, 08 Jul 2020 00:00:00 +0000

优雅的使用SpringBoot注解写代码 SpringBoot常用注解

本篇文章想写一下SpringBoot注解的优雅使用方法。我们所有的工程都离不开配置，那就从配置涉及到的注解开始写起吧。

假设我们的项目是一个数据表结构的迁移项目，用到了两个数据源，一个MySQL的和一个PostgreSQL的。我们项目的目的就是读取MySQL的表结构，生成PostgreSQL的ddl建表语句，生成表结构。

那么第一步，我们就需要配置数据源属性。

1. 配置文件

application.yml配置文件

jdbc：
    mysql:
        enabled: true
        driver-class: com.mysql.jdbc.Driver
        url: this is a mysql url
        username: mysqlUsername
        password: mysqlPassword
    postgresql:
        enabled: flase
        driver-class: org.postgresql.Driver
        url: this is a postgresql url
        username: postgresqlUsername
        password: this is a postgresql password

2. @ConfigurationProperties将配置文件映射为Java Bean键值对类

写好配置文件后，Java要使用配置文件，肯定要先将配置文件封装成Java Bean。使用@ConfigurationProperties即可。如下：

3. 将Properties键值对类引入@Configuration配置类

这里的@Configuration配置类，肯定需要引入Properties键值对类。但是MysqlProperties类上的@ConfigurationProperties注解是不会往容器中注入自身bean的，所以需要@EnableConfigurationProperties启用。

接着就是enabled配置的妙用了，配置@ConditionalOnProperty，当指定的键enabled为指定的值true时，该配置类才生效。

4. 其他注解

@Bean：该注解往容器中注入bean，当Bean不是我们项目中的源码时，无法在其类上加@Component注解使其被容器托管，这是可以使用@Bean注解。
@Import：快速向容器中导入一个类，和@Bean类似都是导入Bean的作用，然而@Import的bean id是全类名，因此一般不会用id来获取bean。@Import配合实现了ImportSelector接口的类，可以有动态的选择的向容器中导入指定Bean。
@Profile：该注解指定了一个环境。SpringBoot中application.yml可以配置多个环境，如application-dev.yml, application-test.yml。SpringBoot应用启动时添加-Dspring.profiles.active=test指定环境，同时也会作用到@Profile注解上。

从Spring启动过程来理解IoC、AOP和bean的生命周期

Tue, 07 Jul 2020 00:00:00 +0000

从Spring启动过程来理解IoC、AOP和bean的生命周期

Spring的基本功能就是IoC和AOP，我们的bean都是交给Spring管理的。那么Spring IoC是怎么生成这些bean、又怎么为指定的bean进行AOP代理增强呢？答案就在Spring的启动流程中。

1. Spring IoC

1.1. 鸟瞰Spring IoC

为了方便，这里使用注解版的写法来启动Spring IoC容器。如下图。

这里先说总结再讲解源码，先理清脉络再深入细节才不会迷失在细节当中。

如上图所示，Spring的启动过程主要可以分为两部分：

第一步：解析成BeanDefinition：将bean定义信息解析为BeanDefinition类，不管bean信息是定义在xml中，还是通过@Bean注解标注，都能通过不同的BeanDefinitionReader转为BeanDefinition类。
- 这里分两种BeanDefinition，RootBeanDefintion和BeanDefinition。RootBeanDefinition这种是系统级别的，是启动Spring必须加载的6个Bean。BeanDefinition是我们定义的Bean。
第二步：参照BeanDefintion定义的类信息，通过BeanFactory生成bean实例存放在缓存中。
- 这里的BeanFactoryPostProcessor是一个拦截器，在BeanDefinition实例化后，BeanFactory生成该Bean之前，可以对BeanDefinition进行修改。
- BeanFactory根据BeanDefinition定义使用反射实例化Bean，实例化和初始化Bean的过程中就涉及到Bean的生命周期了，典型的问题就是Bean的循环依赖。接着，Bean实例化前会判断该Bean是否需要增强，并决定使用哪种代理来生成Bean。

Bean的生命周期如下图，先有个印象即可，到源码部分再回过头来看看Bean的生命周期。

1.2. Spring IoC 源码

我现在用的是Spring 5.2.6的源码，Spring全注解版开发。

第一步就是new一个容器了。

点进去看一下，可以看到主要有三个方法，请记牢这三个方法，this(); register(componentClasses); refresh();

1.2.1. this()方法

点击进入this，看到里层注册了6个RootBeanDefinition，即系统级别的BeanDefinition。

再进去，可以看到注册BeanDefinition其实就是放到BeanFactory的缓存中。

以ConfigurationClassPostProcessor类为例，其实它是一个BeanFactoryPostProcessor拦截器。注意，这部分回调的代码在refresh()中才会执行的。所以下面说的BeanFactoryPostProcessor还不会执行，而是在refresh()中执行。

ConfigurationClassPostProcessor他是拦截配置类并解析里面的Bean定义的。其拦截方法会检查该类是否是配置类。

接着解析配置类。

解析@Import和@Bean

1.2.2. register(componentClasses)方法

这个方法主要就是来注册new AnnotationConfigApplicationContext(xxxConfiguration.class);传进来的配置类的。

1.3. refresh()方法

这是Spring启动中最重要的方法。点进去看一下。其中invokeBeanFactoryPostProcessor故名思意就是调用BeanFactory后置处理器。registerBeanPostProcessors(beanFactory)注册bean后置处理器，Bean后置处理器在Spring中应用很广泛，他能Bean创建过程中的拦截处理器，类似BeanFactoryPostProcessor也是拦截器。

点进这个方法，finishBeanFactoryInitialization(beanFactory)。他是初始化bean的重要方法。bean既可以通过@Bean来定义，也可以通过FactoryBean来初始化。

点击getBean(beanName)看看一个bean是怎么创建的，同时，这也是Bean的生命周期。

看到createBean(beanName, mbd, args)方法

bean创建过程可以分为两步，实例化Instantiation和初始化Initialization。实例化指的是创建bean实例，初始化指的是为填充bean实例属性（为属性赋值）。resolveBeforeInstantiation()方法在bean还没实例化之前执行。提供给Bean后置处理器一个返回代理的机会，当你调用被代理的bean时，实际上是执行了增强了的代理对象。

点进去doCreateBean方法。这里就是bean的生命周期了，如开篇放出的这张图。

bean的生命周期，可以看到第一步就创建了实例

点击该方法createBeanInstance进去，可以看到最终就是通过Java的反射来创建bean对象的。

点进去initializeBean方法查看，可以看到和上面生命周期的图吻合。先检查Aware接口，再到Bean后置处理器的前置处理方法，接着调用初始化方法。

bean的生命周期

至此，bean的IoC容器功能启动流程讲解结束。

Spring AOP

Spring代理增强方面，我们在上面的IoC容器部分看到实例化bean之前，其实是有先判断bean是否需要增强，该方法为resolveBeforeInstantiation(beanName, mdbToUse)，注意该方法是在bean实例化之前的，即先判断是否需要创建代理，如果不需要才会创建bean，否则创建的是代理对象。

夜深了，待续。明天再写写AOP部分的内容。

我来更新啦。

那么，Spring Aop是怎么创建代理的呢，我们来看下resolveBeforeInstantiation(beanName, bdbToUse)方法。

可以看到它调用的是InstantiationAwareBeanPostProcessor这个Bean后置处理器的方法，从类名字上看他是拦截Bean实例化阶段、而不是初始化阶段的。点进去看一下，可以发现他是通过调用InstantiationAwareBeanPostProcessor的回调方法来生成bean对象的。

调用postProcessBeforeInstantiation方法生成对象。

至此，暂且打住。我们来看看我们一般是怎么使用Spring Aop的。

我们会写一个@Aspect注解的切面类，并使用@EnableAspectJAutoProxy注解启用代理。

点进去可以发现，它导入了一个类AspectJAutoProxyRegistrar到Spring容器中。

该类是一个ImportBeanDefinitionRegistrar类，搜索可以发现，ImportBeanDefinitionRegistrar类会在解析配置类的时候调用registerBeanDefinitions方法。

该方法会向容器中注入一个AnnotationAwareAspectJAutoProxyCreator类的Bean定义。

AnnotationAwareAspectJAutoProxyCreator类是一个InstantiationAwareBeanPostProcessor。

讲到这里，就和上面吻合了，实例化bean时现执行InstantiationAwareBeanPostProcessor，如果有返回对象，则使用该对象，否则才去创建实例。所以@EnableAspectJAutoProxy注解的作用就是向容器中添加一个InstantiationAwareBeanPostProcessor类，拦截bean的创建并生成代理对象。

该拦截处理器如下，创建了一个代理对象并返回。

点进来createProxy(beanClass, beanName, specificInterceptor, targetSource)方法并跟踪下层代码，可以发现动态代理创建有两种方式，如果该类是接口，则使用JDK动态代理，否则使用的是Cglib代理。

至此，Aop部分代码讲解结束。

其中，IoC的循环依赖问题和Aop的拦截器链设计有兴趣的可以推荐看一下源码。

黄泽彬

十分钟完成的操作系统att版本

十分钟完成的操作系统at&t版本-《一个操作系统的实现》

WSL图形界面

WSL图形界面

WSL安装xfce4

1. 更新软件源

2. wsl中安装xfce4

3. window安装VcXsrv

4. 在WSL执行命令启动图形界面

Zookeeper源码调试环境踩坑记录

Zookeeper源码调试环境踩坑记录

1. 下载源码

2. maven下载jar包

3. 找入口类

4. 启动报错

Netty源码服务器启动流程

Netty源码服务器启动流程

EventLoopGroup事件循环组

NioEventLoop事件循环

Channel通道

Pipeline管道

register注册

SocketChannel连接分配

轻松理解Shiro与实战

轻松理解Shiro与实战

Spring Boot整合Shiro

表设计

用户表base_user

角色表

资源表

用户角色表

角色资源表

脚本整理

导入shiro-spring-boot-web-starter

拦截所有页面

前后端分离按钮显示

Shiro如何识别用户

推荐阅读

写给后端的前端快速搭建笔记

写给后端的前端快速搭建笔记

创建项目

开始开发

导入文件进行显示

页面布局

从RocketMQ源码了解其系统设计

从RocketMQ源码了解其系统设计

消息发送总流程

RocketMQ模型概念

RocketMQ路由中心NameServer

NameServer路由注册和故障剔除

Broker心跳

路由发现

RocketMQ消息发送

Producer启动

查找主题路由信息

选择消息队列

RocketMQ消息存储

RocketMQ相关文件

过期文件定期删除

RocketMQ消息消费

消费者启动

拉取消息

定时消息机制

消息重试机制

服务端处理消息拉取

docker安装部署rocketmq和SpringBoot小实例

docker安装部署rocketmq和SpringBoot小实例

1. 部署NameServer

2. 部署Broker

3. 部署RocketMQ可视化界面控制台

4. SpringBoot整合RocketMQ小实例

优雅地使用SpringBoot注解写代码 SpringBoot常用注解

优雅的使用SpringBoot注解写代码 SpringBoot常用注解

1. 配置文件

2. @ConfigurationProperties将配置文件映射为Java Bean键值对类

3. 将Properties键值对类引入@Configuration配置类

4. 其他注解

从Spring启动过程来理解IoC、AOP和bean的生命周期

从Spring启动过程来理解IoC、AOP和bean的生命周期