复制代码　索引是一种用于快速查询行的数据结构，就像一本书的目录就是一个索引，如果想在一本书中找到某个主题，
　一般会先找到对应页码。在mysql中，存储引擎用类似的方法使用索引，先在索引中找到对应值
　然后根据匹配的索引记录找到对应的行。

css复制代码大多数存储引擎都支持B树索引。b树通常意味着所有的值都是按顺序存储的，并且每一个叶子也到根的距离相同。
B树索引能够加快访问数据的速度，因为存储引擎不再需要进行全表扫描来获取数据。
下图就是一颗简单的B树。

sql复制代码create table Student(
    last_name varchar(50) not null, 
    first_name varchar(50) not null, 
    birthday date not null, 
    gender int(2) not null, 
    key(last_name, first_name, birthday)
);

sql复制代码create table Student(
    id int(11) primary key auto_increment,
    last_name varchar(50) not null, 
    first_name varchar(50) not null, 
    birthday date not null
);

scss复制代码create table layout_test(
    col1 int(11) primary key, 
    col2 int(11) not null, 
    key(col2)
);

markdown复制代码/**
 * The following code shows how to use {@code Optional.isPresent}:
 * {@snippet :
 * if (v.isPresent()) {
 *     System.out.println("v: " + v.get());
 * }
 * }
 */

perl复制代码/**
 * The following code shows how to use {@code Optional.isPresent}:
 * {@snippet file="ShowOptional.java" region="example"}
 */

csharp复制代码public class ShowOptional {
    void show(Optional<String> v) {
        // @start region="example"
        if (v.isPresent()) {
            System.out.println("v: " + v.get());
        }
        // @end
    }
}

java复制代码public class FindLargestSmallestNumberMain {

    public static void main(String[] args) {

        int arr[] = new int[]{12,56,76,89,100,343,21,234};
        //将第一个元素赋值给
        int min = arr[0];
        int max = arr[0];

        for(int i=1; i< arr.length; i++)
        {
            if(arr[i] > max)
                max = arr[i];
            else if (arr[i] < min)
                min = arr[i];
        }
        System.out.println("Smallest Number is : " + min);
        System.out.println("max Number is : " + max); 
    }
}

java复制代码int[] arr1={7,5,6,1,4,2};
Missing number : 3
int[] arr2={5,3,1,2};
Missing number : 4

java复制代码public class MissingNumberMain {
 
    public static void main(String[] args) {
 
        int[] arr1={7,5,6,1,4,2};
        System.out.println("Missing number from array arr1: "+missingNumber(arr1));
        int[] arr2={5,3,1,2};
        System.out.println("Missing number from array arr2: "+missingNumber(arr2));
 
    }
 
    public static int missingNumber(int[] arr)
    {
        int n=arr.length+1;
        int sum=n*(n+1)/2;
        int restSum=0;
        for (int i = 0; i < arr.length; i++) {
            restSum+=arr[i];
        }
        int missingNumber=sum-restSum;
        return missingNumber;
    }
}

java复制代码int arr[]={16,19,21,25,3,5,8,10};

java复制代码public class SearchElementSortedAndRotatedArrayMain {

    public static void main(String[] args) {
        int arr[] = {16, 19, 21, 25, 3, 5, 8, 10};
        System.out.println("Index of element 5 : " + findElementRotatedSortedArray(arr, 0, arr.length - 1, 5));
    }

    public static int findElementRotatedSortedArray(int[] arr, int low, int high, int number) {
        int mid;
        while (low <= high) {
            mid = low + ((high - low) / 2);

            if (arr[mid] == number) {
                return mid;
            }
            if (arr[mid] <= arr[high]) {
                // 右边部分是有序的
                if (number > arr[mid] && number <= arr[high]) {
                    low = mid + 1;
                } else {
                    high = mid - 1;
                }
            } else {
                // 左边部分是有序的
                if (arr[low] <= number && number < arr[mid]) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
        }
        return -1;
    }
}

java复制代码int arr[]={16,19,21,25,3,5,8,10};

java复制代码public class MinimumElementSortedAndRotatedArrayMain {

    public static void main(String[] args) {
        int arr[] = {16, 19, 21, 25, 3, 5, 8, 10};
        System.out.println("Minimum element in the array : " + findMinimumElementRotatedSortedArray(arr, 0, arr.length - 1));
    }
    public static int findMinimumElementRotatedSortedArray(int[] arr, int low, int high) {
        int mid;
        while (low < high) {
            mid = low + ((high - low) / 2);
            if (arr[mid] < arr[high]) {
                high = mid;
            } else {
                low = mid+1;
            }
        }
        return arr[low];
    }
}

java复制代码int[] arr1={7,5,6,1,4,2};

java复制代码public class FindSecondLargestMain {
    public static void main(String args[]) {
        int[] arr1 = {7, 5, 6, 1, 4, 2};
        int secondHighest = findSecondLargestNumberInTheArray(arr1);
        System.out.println("Second largest element in the array : " + secondHighest);
    }

    public static int findSecondLargestNumberInTheArray(int array[]) {
        int highest = Integer.MIN_VALUE;
        int secondHighest = Integer.MIN_VALUE;

        // 遍历数组
        for (int i = 0; i < array.length; i++) {
            // 如果当前值大于最大值
            if (array[i] > highest) {
                // 最大值赋值给第二大值
                secondHighest = highest;
                // 当前值赋值给最大值
                highest = array[i];
            } else if (array[i] > secondHighest && array[i] != highest)
                // 将当前值赋值给第二大值
                secondHighest = array[i];
        }
        return secondHighest;
    }
}

java复制代码int getOddTimesElementHashing(int ar[]) {
        int i;
        HashMap<Integer, Integer> elements = new HashMap<Integer, Integer>();
        for (i = 0; i < ar.length; i++) {
            int element = ar[i];
            if (elements.get(element) == null) {
                elements.put(element, 1);
            } else{
                elements.put(element, elements.get(element) + 1);
            }
        }
        for (Entry<Integer, Integer> entry : elements.entrySet()) {
            if (entry.getValue() % 2 == 1) {
                return entry.getKey();
            }
        }
        return -1;
    }

java复制代码int getOddTimesElement(int arr[]) {
    int i;
    int result = 0;
    for (i = 0; i < arr.length; i++) {
        result = result ^ arr[i];
    }
    return result;
}

java复制代码// 到达时刻表
arrival[] = {1:00, 1:40, 1:50, 2:00, 2:15, 4:00}
// 出站时刻表
departure[] = {1:10, 3:00, 2:20, 2:30, 3:15, 6:00}
// 最少需要的站台数 = 4

java复制代码public class TrainPlatformMain {
    public static void main(String args[]) {
        // arr[] = {1:00, 1:40, 1:50, 2:00, 2:15, 4:00}
        // dep[] = {1:10, 3:00, 2:20, 2:30, 3:15, 6:00}
        int arr[] = {100, 140, 150, 200, 215, 400};
        int dep[] = {110, 300, 210, 230, 315, 600};
        System.out.println("最少需要的站台数 =" + findPlatformsRequiredForStation(arr, dep, arr.length));
    }

    static int findPlatformsRequiredForStation(int arr[], int dep[], int n) {
        int platform_needed = 0, maxPlatforms = 0;
        Arrays.sort(arr);
        Arrays.sort(dep);
        int i = 0, j = 0;
        // 类似归并排序中的归并操作
        while (i < n && j < n) {
            if (arr[i] < dep[j]) {
                platform_needed++;
                i++;
                if (platform_needed > maxPlatforms)
                    maxPlatforms = platform_needed;
            } else {
                platform_needed--;
                j++;
            }
        }
        return maxPlatforms;
    }
}

java复制代码array[]={1,3,-5,7,8,20,-40,6};
// 和最接近0的两个数是 :  -5 and 6

java复制代码public static void findPairWithMinSumBruteForce(int arr[]) {
    if (arr.length < 2)
        return;
    // 预设前两个数的和最接近于0
    int minimumSum = arr[0] + arr[1];
    int pair1stIndex = 0;
    int pair2ndIndex = 1;
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            int tempSum = arr[i] + arr[j];
            if (Math.abs(tempSum) < Math.abs(minimumSum)) {
                pair1stIndex = i;
                pair2ndIndex = j;
                minimumSum = tempSum;
            }
        }
    }
    System.out.println(" 和最接近0的两个数是 : " + arr[pair1stIndex] + " " + arr[pair2ndIndex]);
}

java复制代码public static void findPairWithMinSum(int arr[]) {
    Arrays.sort(arr);
    int sum = 0;
    int minimumSum = Integer.MAX_VALUE;
    int n = arr.length;
    // left and right index variables
    int l = 0, r = n - 1;

    int minLeft = l, minRight = n - 1;

    while (l < r) {
        sum = arr[l] + arr[r];
        // 如果abs(sum)<abs(minSum)，将l和r记录在最小的两个数组元素变量上;
        if (Math.abs(sum) < Math.abs(minimumSum)) {
            minimumSum = sum;
            minLeft = l;
            minRight = r;
        }
        if (sum < 0)
            l++;
        else
            r--;
    }
    System.out.println(" 和最接近0的两个数是 : " + arr[minLeft] + " " + arr[minRight]);
}

java复制代码public static void findPairWithClosestToX(int arr[], int X) {
    Arrays.sort(arr);
    int minimumDiff = Integer.MAX_VALUE;
    int n = arr.length;

    int l = 0, r = n - 1;

    int minLeft = l, minRight = n - 1;
    while (l < r) {
        int currentDiff = Math.abs(arr[l] + arr[r] - X);
        // 如果abs(diff)<minDiff，将l和r记录在最小的两个数组元素变量上
        if (currentDiff < minimumDiff) {
            minimumDiff = currentDiff;
            minLeft = l;
            minRight = r;
        }
        if (arr[l] + arr[r] < X)
            l++;
        else
            r--;
    }
    System.out.println(" 和最接近X的两个数是 : " + arr[minLeft] + " " + arr[minRight]);
}

java复制代码public static void findPairsWithSumEqualsToXBruteForce(int arr[], int X) {
    if (arr.length < 2)
        return;
    System.out.println("暴力破解两数之和等于X的组合: ");
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            int tempSum = arr[i] + arr[j];

            if (tempSum == X) {
                System.out.println(arr[i] + " " + arr[j]);
            }
        }
    }
}

java复制代码public static void findPairsEqualsToX(int arr[], int X) {
    int n = arr.length;
    if (n < 2)
        return;
    Arrays.sort(arr);
    System.out.println("两数之和等于X的组合: ");

    int l = 0, r = n - 1;

    while (l < r) {
        int currentSum = arr[l] + arr[r];
        if (currentSum == X) {
            System.out.println(arr[l] + " " + arr[r]);
            l++;
            r--;
        } else if (arr[l] + arr[r] < X)
            l++;
        else
            r--;
    }
}

java复制代码public static void findPairsEqualsToXUsingHashing(int arr[], int X) {
    HashMap<Integer, Integer> elementIndexMap = new HashMap<>();
    System.out.println("两数之和等于X的组合: ");
    for (int i = 0; i < arr.length; i++) {
        elementIndexMap.put(arr[i], i);
    }
    for (int i = 0; i < arr.length; i++) {
        if (elementIndexMap.get(X - arr[i]) != null && elementIndexMap.get(X - arr[i]) != i) //
        {
            System.out.println(arr[i] + " " + (X - arr[i]));
        }
    }
}

yaml复制代码logging:
  level:
    root: info
    mapper包名: debug

ini复制代码<select id="getProductInfoList" resultMap="productMap">
    select
    t.*
    from
    type_product t
    where 1=1 AND t.is_deleted = 'N'
    <if test="productTypeId != null and productTypeId != '' ">
        and t.product_type_id=#{productTypeId}
    </if>
    <if test="productTypeTagId != null and productTypeTagId != '' ">
        and t.product_type_tag_id=#{productTypeTagId}
    </if>
    group by product_id
</select>

xml复制代码<resultMap id="productMap" type="com.baoyun.iyb.app.dao.dataobject.ProductInfo">
    <id column="id" property="id"></id>
    <result column="product_name" property="productName"></result>
    <result column="product_id" property="productId"></result>
    <result column="description" property="description"></result>
    <result column="product_img_url" property="productImgUrl"></result>
    <result column="gmt_modified" property="gmtModified"></result>
    <!-- 查询标签 -->
    <collection property="tags" column="product_id" ofType="com.baoyun.iyb.app.dao.dataobject.Tag"
                select="com.baoyun.iyb.app.dao.mapper.TagMapper.getTags">
        <result column="tag_name" property="tagName"></result>
        <result column="tag_title" property="tagTitle"></result>
        <result column="tag_content" property="tagContent"></result>
    </collection>
</resultMap>

ini复制代码<resultMap type="Student" id="StudentMap2">
    <id column="id" property="id" />
    <result column="name" property="name" />
    <result column="job" property="job" />
    <collection property="scores" javaType="java.util.ArrayList" ofType="Score">
        <id column="id" property="id" />
        <result column="num" property="num" />
        <association property="subject" javaType="Subject">
            <id column="id" property="id" />
            <result column="name" property="name" />
        </association>
    </collection>
</resultMap>
<select id="queryStudents2" resultMap="StudentMap2" >
    SELECT stu.id,stu.name name,stu.job,sco.id id,sco.num num,sub.id id,sub.name name
    FROM t_student stu LEFT JOIN t_score sco ON stu.id = sco.sid LEFT JOIN t_subject sub ON sco.subject = sub.id
</select>

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.72</version>
</dependency>
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
</dependency>

java复制代码public interface IUserService {

    String saveUser(String name);
}

java复制代码@Service
@Slf4j
public class UserServiceImpl implements IUserService {
    @Override
    public String saveUser(String name) {
        log.info("begin saveUser:"+name);
        return "Save User Success!";
    }
}

java复制代码@ComponentScan(basePackages = {"com.example.spring","com.example.service"})  //case1(后续再加上)
@SpringBootApplication
public class NettyRpcProviderMain {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(NettyRpcProviderMain.class, args);
        new NettyServer("127.0.0.1",8080).startNettyServer();   //case2(后续再加上)
    }
}

txt复制代码    /*
    +----------------------------------------------+
    | 魔数 2byte | 序列化算法 1byte | 请求类型 1byte  |
    +----------------------------------------------+
    | 消息 ID 8byte     |      数据长度 4byte       |
    +----------------------------------------------+
    */

java复制代码@AllArgsConstructor
@Data
public class Header implements Serializable {
    /*
    +----------------------------------------------+
    | 魔数 2byte | 序列化算法 1byte | 请求类型 1byte  |
    +----------------------------------------------+
    | 消息 ID 8byte     |      数据长度 4byte       |
    +----------------------------------------------+
    */
    private short magic; //魔数-用来验证报文的身份（2个字节）
    private byte serialType; //序列化类型（1个字节）
    private byte reqType; //操作类型（1个字节）
    private long requestId; //请求id（8个字节）
    private int length; //数据长度（4个字节）

}

java复制代码@Data
public class RpcRequest implements Serializable {
    private String className;
    private String methodName;
    private Object[] params;
    private Class<?>[] parameterTypes;
}

java复制代码@Data
public class RpcResponse implements Serializable {

    private Object data;
    private String msg;
}

java复制代码@Data
public class RpcProtocol<T> implements Serializable {
    private Header header;
    private T content;
}

java复制代码public enum ReqType {

    REQUEST((byte)1),
    RESPONSE((byte)2),
    HEARTBEAT((byte)3);

    private byte code;

    private ReqType(byte code) {
        this.code=code;
    }

    public byte code(){
        return this.code;
    }
    public static ReqType findByCode(int code) {
        for (ReqType msgType : ReqType.values()) {
            if (msgType.code() == code) {
                return msgType;
            }
        }
        return null;
    }
}

java复制代码public enum SerialType {

    JSON_SERIAL((byte)0),
    JAVA_SERIAL((byte)1);

    private byte code;

    SerialType(byte code) {
        this.code=code;
    }

    public byte code(){
        return this.code;
    }
}

java复制代码public class RpcConstant {
    //header部分的总字节数
    public final static int HEAD_TOTAL_LEN=16;
    //魔数
    public final static short MAGIC=0xca;
}

java复制代码public interface ISerializer {

    <T> byte[] serialize(T obj);

    <T> T deserialize(byte[] data,Class<T> clazz);

    byte getType();
}

java复制代码public class JavaSerializer implements ISerializer{

    @Override
    public <T> byte[] serialize(T obj) {
        ByteArrayOutputStream byteArrayOutputStream=
                new ByteArrayOutputStream();
        try {
            ObjectOutputStream outputStream=
                    new ObjectOutputStream(byteArrayOutputStream);

            outputStream.writeObject(obj);

            return  byteArrayOutputStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new byte[0];
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        ByteArrayInputStream byteArrayInputStream=new ByteArrayInputStream(data);
        try {
            ObjectInputStream objectInputStream=
                    new ObjectInputStream(byteArrayInputStream);

            return (T) objectInputStream.readObject();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public byte getType() {
        return SerialType.JAVA_SERIAL.code();
    }
}

java复制代码public class JsonSerializer implements ISerializer{
    @Override
    public <T> byte[] serialize(T obj) {
        return JSON.toJSONString(obj).getBytes();
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        return JSON.parseObject(new String(data),clazz);
    }

    @Override
    public byte getType() {
        return SerialType.JSON_SERIAL.code();
    }
}

java复制代码public class SerializerManager {

    private final static ConcurrentHashMap<Byte, ISerializer> serializers=new ConcurrentHashMap<Byte, ISerializer>();

    static {
        ISerializer jsonSerializer=new JsonSerializer();
        ISerializer javaSerializer=new JavaSerializer();
        serializers.put(jsonSerializer.getType(),jsonSerializer);
        serializers.put(javaSerializer.getType(),javaSerializer);
    }

    public static ISerializer getSerializer(byte key){
        ISerializer serializer=serializers.get(key);
        if(serializer==null){
            return new JavaSerializer();
        }
        return serializer;
    }
}

java复制代码@Slf4j
public class RpcDecoder extends ByteToMessageDecoder {


    /*
    +----------------------------------------------+
    | 魔数 2byte | 序列化算法 1byte | 请求类型 1byte  |
    +----------------------------------------------+
    | 消息 ID 8byte     |      数据长度 4byte       |
    +----------------------------------------------+
    */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        log.info("==========begin RpcDecoder ==============");
        if(in.readableBytes()< RpcConstant.HEAD_TOTAL_LEN){
            //消息长度不够，不需要解析
            return;
        }
        in.markReaderIndex();//标记一个读取数据的索引，后续用来重置。
        short magic=in.readShort(); //读取magic
        if(magic!=RpcConstant.MAGIC){
            throw new IllegalArgumentException("Illegal request parameter 'magic',"+magic);
        }
        byte serialType=in.readByte(); //读取序列化算法类型
        byte reqType=in.readByte(); //请求类型
        long requestId=in.readLong(); //请求消息id
        int dataLength=in.readInt(); //请求数据长度
        //可读区域的字节数小于实际数据长度
        if(in.readableBytes()<dataLength){
            in.resetReaderIndex();
            return;
        }
        //读取消息内容
        byte[] content=new byte[dataLength];
        in.readBytes(content);

        //构建header头信息
        Header header=new Header(magic,serialType,reqType,requestId,dataLength);
        ISerializer serializer=SerializerManager.getSerializer(serialType);
        ReqType rt=ReqType.findByCode(reqType);
        switch(rt){
            case REQUEST:
                RpcRequest request=serializer.deserialize(content, RpcRequest.class);
                RpcProtocol<RpcRequest> reqProtocol=new RpcProtocol<>();
                reqProtocol.setHeader(header);
                reqProtocol.setContent(request);
                out.add(reqProtocol);
                break;
            case RESPONSE:
                RpcResponse response=serializer.deserialize(content,RpcResponse.class);
                RpcProtocol<RpcResponse> resProtocol=new RpcProtocol<>();
                resProtocol.setHeader(header);
                resProtocol.setContent(response);
                out.add(resProtocol);
                break;
            case HEARTBEAT:
                break;
            default:
                break;
        }

    }
}

java复制代码@Slf4j
public class RpcEncoder extends MessageToByteEncoder<RpcProtocol<Object>> {

    /*
    +----------------------------------------------+
    | 魔数 2byte | 序列化算法 1byte | 请求类型 1byte  |
    +----------------------------------------------+
    | 消息 ID 8byte     |      数据长度 4byte       |
    +----------------------------------------------+
    */
    @Override
    protected void encode(ChannelHandlerContext ctx, RpcProtocol<Object> msg, ByteBuf out) throws Exception {
        log.info("=============begin RpcEncoder============");
        Header header=msg.getHeader();
        out.writeShort(header.getMagic()); //写入魔数
        out.writeByte(header.getSerialType()); //写入序列化类型
        out.writeByte(header.getReqType());//写入请求类型
        out.writeLong(header.getRequestId()); //写入请求id
        ISerializer serializer= SerializerManager.getSerializer(header.getSerialType());
        byte[] data=serializer.serialize(msg.getContent()); //序列化
        header.setLength(data.length);
        out.writeInt(data.length); //写入消息长度
        out.writeBytes(data);
    }
}

java复制代码@Slf4j
public class NettyServer{
    private String serverAddress; //地址
    private int serverPort; //端口

    public NettyServer(String serverAddress, int serverPort) {
        this.serverAddress = serverAddress;
        this.serverPort = serverPort;
    }

    public void startNettyServer() throws Exception {
        log.info("begin start Netty Server");
        EventLoopGroup bossGroup=new NioEventLoopGroup();
        EventLoopGroup workGroup=new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new RpcServerInitializer());
            ChannelFuture channelFuture = bootstrap.bind(this.serverAddress, this.serverPort).sync();
            log.info("Server started Success on Port:{}", this.serverPort);
            channelFuture.channel().closeFuture().sync();
        }catch (Exception e){
            log.error("Rpc Server Exception",e);
        }finally {
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

java复制代码public class RpcServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline()
            .addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,12,4,0,0))
            .addLast(new RpcDecoder())
            .addLast(new RpcEncoder())
            .addLast(new RpcServerHandler());
    }
}

java复制代码public class RpcServerHandler extends SimpleChannelInboundHandler<RpcProtocol<RpcRequest>> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcProtocol<RpcRequest> msg) throws Exception {
        RpcProtocol resProtocol=new RpcProtocol<>();
        Header header=msg.getHeader();
        header.setReqType(ReqType.RESPONSE.code());
        Object result=invoke(msg.getContent());
        resProtocol.setHeader(header);
        RpcResponse response=new RpcResponse();
        response.setData(result);
        response.setMsg("success");
        resProtocol.setContent(response);

        ctx.writeAndFlush(resProtocol);
    }

    private Object invoke(RpcRequest request){
        try {
            Class<?> clazz=Class.forName(request.getClassName());
            Object bean= SpringBeansManager.getBean(clazz); //获取实例对象(CASE)
            Method declaredMethod=clazz.getDeclaredMethod(request.getMethodName(),request.getParameterTypes());
            return declaredMethod.invoke(bean,request.getParams());
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
    }
}

java复制代码@Component
public class SpringBeansManager implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringBeansManager.applicationContext=applicationContext;
    }

    public static <T> T getBean(Class<T> clazz){
        return applicationContext.getBean(clazz);
    }
}

java复制代码@ComponentScan(basePackages = {"com.example.spring","com.example.service"})  //修改这里
@SpringBootApplication
public class NettyRpcProviderMain {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(NettyRpcProviderMain.class, args);
        new NettyServer("127.0.0.1",8080).startNettyServer();  // 修改这里
    }
}

java复制代码public class RpcClientProxy {
    
    public <T> T clientProxy(final Class<T> interfaceCls,final String host,final int port){
        return (T) Proxy.newProxyInstance
                (interfaceCls.getClassLoader(),
                        new Class<?>[]{interfaceCls},
                        new RpcInvokerProxy(host,port));
    }
}

java复制代码@Slf4j
public class RpcInvokerProxy implements InvocationHandler {

    private String serviceAddress;
    private int servicePort;

    public RpcInvokerProxy(String serviceAddress, int servicePort) {
        this.serviceAddress = serviceAddress;
        this.servicePort = servicePort;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("begin invoke target server");
        //组装参数
        RpcProtocol<RpcRequest> protocol=new RpcProtocol<>();
        long requestId= RequestHolder.REQUEST_ID.incrementAndGet();
        Header header=new Header(RpcConstant.MAGIC, SerialType.JSON_SERIAL.code(), ReqType.REQUEST.code(),requestId,0);
        protocol.setHeader(header);
        RpcRequest request=new RpcRequest();
        request.setClassName(method.getDeclaringClass().getName());
        request.setMethodName(method.getName());
        request.setParameterTypes(method.getParameterTypes());
        request.setParams(args);
        protocol.setContent(request);
        //发送请求
        NettyClient nettyClient=new NettyClient(serviceAddress,servicePort);
        //构建异步数据处理
        RpcFuture<RpcResponse> future=new RpcFuture<>(new DefaultPromise<>(new DefaultEventLoop()));
        RequestHolder.REQUEST_MAP.put(requestId,future);
        nettyClient.sendRequest(protocol);
        return future.getPromise().get().getData();
    }
}

java复制代码@Slf4j
public class NettyClient {
    private final Bootstrap bootstrap;
    private final EventLoopGroup eventLoopGroup=new NioEventLoopGroup();
    private String serviceAddress;
    private int servicePort;
    public NettyClient(String serviceAddress,int servicePort){
        log.info("begin init NettyClient");
        bootstrap=new Bootstrap();
        bootstrap.group(eventLoopGroup)
                .channel(NioSocketChannel.class)
                .handler(new RpcClientInitializer());
        this.serviceAddress=serviceAddress;
        this.servicePort=servicePort;
    }

    public void sendRequest(RpcProtocol<RpcRequest> protocol) throws InterruptedException {
        ChannelFuture future=bootstrap.connect(this.serviceAddress,this.servicePort).sync();
        future.addListener(listener->{
            if(future.isSuccess()){
                log.info("connect rpc server {} success.",this.serviceAddress);
            }else{
                log.error("connect rpc server {} failed .",this.serviceAddress);
                future.cause().printStackTrace();
                eventLoopGroup.shutdownGracefully();
            }
        });
        log.info("begin transfer data");
        future.channel().writeAndFlush(protocol);
    }
}

java复制代码@Slf4j
public class RpcClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        log.info("begin initChannel");
        ch.pipeline()
                .addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,12,4,0,0))
                .addLast(new LoggingHandler())
                .addLast(new RpcEncoder())
                .addLast(new RpcDecoder())
                .addLast(new RpcClientHandler());
    }
}

java复制代码@Slf4j
public class RpcClientHandler extends SimpleChannelInboundHandler<RpcProtocol<RpcResponse>> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcProtocol<RpcResponse> msg) throws Exception {
        log.info("receive rpc server result");
        long requestId=msg.getHeader().getRequestId();
        RpcFuture<RpcResponse> future=RequestHolder.REQUEST_MAP.remove(requestId);
        future.getPromise().setSuccess(msg.getContent()); //返回结果
    }
}

java复制代码@Data
public class RpcFuture<T> {
    //Promise是可写的 Future, Future自身并没有写操作相关的接口,
    // Netty通过 Promise对 Future进行扩展,用于设置IO操作的结果
    private Promise<T> promise;

    public RpcFuture(Promise<T> promise) {
        this.promise = promise;
    }
}

java复制代码public class RequestHolder {

    public static final AtomicLong REQUEST_ID=new AtomicLong();

    public static final Map<Long,RpcFuture> REQUEST_MAP=new ConcurrentHashMap<>();
}

css复制代码app3
├── lib
│   └── main.dart
└── pubspce.yaml

css复制代码library animation;

export 'src/animation/animation.dart';
export 'src/animation/animation_controller.dart';
export 'src/animation/animations.dart';
export 'src/animation/curves.dart';
export 'src/animation/listener_helpers.dart';
export 'src/animation/tween.dart';
export 'src/animation/tween_sequence.dart';

arduino复制代码import 'package:flutter/animation.dart';

dart复制代码export 'src/hw_none.dart' // Stub implementation
    if (dart.library.io) 'src/hw_io.dart' // dart:io implementation
    if (dart.library.html) 'src/hw_html.dart'; // dart:html implementation

csharp复制代码/// The event handler responsible for updating the badge in the UI.
void updateBadge() {
  ...
}

arduino复制代码输入: ["abcw","baz","foo","bar","xtfn","abcdef"]

输出: 16 

解释: 这两个单词为 "abcw", "xtfn"。

arduino复制代码输入: ["a","ab","abc","d","cd","bcd","abcd"]

输出: 4 

解释: 这两个单词为 "ab", "cd"。

less复制代码输入: ["a","aa","aaa","aaaa"]

输出: 0 

解释: 不存在这样的两个单词。

Java复制代码class Solution {
    public int maxProduct(String[] words) {
        int n = words.length, idx = 0;
        int[] masks = new int[n];
        for (String w : words) {
            int t = 0;
            for (int i = 0; i < w.length(); i++) {
                int u = w.charAt(i) - 'a';
                t |= (1 << u);
            }
            masks[idx++] = t;
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if ((masks[i] & masks[j]) == 0) ans = Math.max(ans, words[i].length() * words[j].length());
            }
        }
        return ans;
    }
}

Java复制代码class Solution {
    public int maxProduct(String[] words) {
        Map<Integer, Integer> map = new HashMap<>();
        for (String w : words) {
            int t = 0, m = w.length();
            for (int i = 0; i < m; i++) {
                int u = w.charAt(i) - 'a';
                t |= (1 << u);
            }
            if (!map.containsKey(t) || map.get(t) < m) map.put(t, m);
        }
        int ans = 0;
        for (int a : map.keySet()) {
            for (int b : map.keySet()) {
                if ((a & b) == 0) ans = Math.max(ans, map.get(a) * map.get(b));
            }
        }
        return ans;
    }
}

c复制代码算术操作符： + - * / %

c复制代码移位操作符： << >>

c复制代码位操作符： & | ^

c复制代码赋值操作符： =  +=  -=  *=  /=  %=  &=  ^=  & *

c复制代码单目操作符: sizeof ! ++ --

c复制代码关系操作符： > >= <= < != ==

c复制代码逻辑操作符： && ||

c复制代码条件操作符:  ?:		唯一的一个三木操作符

c复制代码逗号表达式: .

c复制代码下标引用，函数调用和结构成员: []  ()  .  ->

c复制代码int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	printf("输入两个操作数:->\n");	// 5 2
	scanf("%d %d", &a, &b);
	c = a / b;
	printf("结果为: %d\n", c);	// 2
	return 0;
}

c复制代码//若接收类型为double类型
  int main()
{
	int a = 0;
	int b = 0;
	double c = 0;
	printf("输入两个操作数:->\n");	// 5 2
	scanf("%d %d", &a, &b);
	c = a / b;
	printf("结果为: %lf\n", c);	// 2.000000  并不是2.500000
	return 0;
}

c复制代码int a = 10;
int b = 3;
int c = a % b;

c复制代码int a = 10;
double b = 3;	
int c = a % b;//err

c复制代码int a = 10;
int b = 3;
double c = a % b; 	//接收类型可以为其他类型

c复制代码int c = 4;
c << 1;
printf("%d\n",c);	//4还是8？
//4  原因：并没有接收c << 1的值

//若想结果位8
 c  = c<< 1;
printf("%d\n",c); 	//8

c复制代码情形1：逻辑右移：左边用0填充，右边丢弃
情形2：算术右移：左边补符号位，右边丢弃

c复制代码int a = 1;
// 00000000 00000000 00000000 00000001  --原码
//正数：原反补相同

//若采取的是逻辑右移
// 00000000 00000000 00000000 00000000 -补码
//最高位为符号位：0，正数  原反补相同
//对应原码为：00000000 00000000 00000000 00000000 -打印结果为0
a = a >> 1;
printf("%d\n",a);	//0

c复制代码//err写法
int a = 15;
int b = a >> -1;		//C语言标准未被定义的写法

c复制代码float c = 4,5f;
c >> 1;	//err

c复制代码 1001
&1111
-----
 1001   
//对应比特位进行按位与运算  有0则为0 两个比特位都为1，结果才为1

c复制代码 1001
|1111
-----
 1111  
//对应比特位进行按位与运算  有1则为1 两个比特位都为0，结果才为0

c复制代码 1001
^1111
-----
 0110
//对应比特位进行按位异或运算  对应比特位相同为0 不同为1

c复制代码如： X: 1100 0011 使倒数第三个二进制位翻转
   使1100 0011异或上0000 0100
 ==> 1100 0011
    ^0000 0100
    ----------
     1100 0111  ==>这样的话就使X的倒数第三位翻转了

c复制代码使特定位翻转：
   对应X要翻转的比特位，该数的对应位为1，其他位为0，次数与X对应位异或即可
   如：X = 10101110  使X的低4字节位翻转，
    X ^ 0000 1111即可
  ==>1010 1110 
    ^0000 1111
  ==>1010 0001  ->x的低4位翻转了

c复制代码int a  =15;
// 00000000 00000000 00000000 00001111   ->a的补码
//&00000000 00000000 00000000 00000001   ->1的补码
--------------------------------------
// 00000000 00000000 00000000 00000001  ->结果为1  
    //即a的最后一位比特位为1

c复制代码int main()
{
    int a = 0;
    int b = 0;
    scanf("%d",&b);
    a = b &1;
    printf("%d补码的最后一位比特位是%d",b,a);
}