前言
这段时间一直在学习Netty相关知识，因为涉及知识点比较多，也走了不少弯路。目前网上关于Netty学习资料琳琅满目，不知如何下手，其实大家都是一样的，学习方法和技巧都是总结出来的，我们在没有找到很好的方法之前不如按部就班先从基础开始，一般从总分总的渐进方式，既观森林，又见草木。
Netty是一款提供异步的、事件驱动的网络应用程序框架和工具，是基于NIO客户端、服务器端的编程框架。所以这里我们先以NIO和依赖相关的基础铺垫来进行剖析讲解，从而作为Netty学习之旅的一个开端。
RPC概述
RPC(Remote Procedure Call)即远程过程调用，允许一台计算机调用另一台计算机上的程序得到结果，而代码中不需要做额外的编程，就像在本地调用一样。
现在互联网应用的量级越来越大，单台计算机的能力有限，需要借助可扩展的计算机集群来完成，分布式的应用可以借助RPC来完成机器之间的调用。
RPC框架原理
在RPC框架中主要有三个角色：Provider、Consumer和Registry。如下图所示：

节点角色说明：


Server: 暴露服务的服务提供方。


Client: 调用远程服务的服务消费方。


Registry: 服务注册与发现的注册中心。


RPC调用流程
RPC基本流程图：

一次完整的RPC调用流程（同步调用，异步另说）如下：
1）服务消费方（client）调用以本地调用方式调用服务；
2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
3）client stub找到服务地址，并将消息发送到服务端；
4）server stub收到消息后进行解码；
5）server stub根据解码结果调用本地的服务；
6）本地服务执行并将结果返回给server stub；
7）server stub将返回结果打包成消息并发送至消费方；
8）client stub接收到消息，并进行解码；
9）服务消费方得到最终结果。
RPC框架的目标就是要2~8这些步骤都封装起来，让用户对这些细节透明。
服务注册&发现

服务提供者启动后主动向注册中心注册机器ip、port以及提供的服务列表；
服务消费者启动时向注册中心获取服务提供方地址列表，可实现软负载均衡和Failover；
使用到的技术
1、动态代理
生成 client stub和server stub需要用到 Java 动态代理技术 ，我们可以使用JDK原生的动态代理机制，可以使用一些开源字节码工具框架 如：CgLib、Javassist等。
2、序列化
为了能在网络上传输和接收 Java对象，我们需要对它进行 序列化和反序列化操作。


序列化：将Java对象转换成byte[]的过程，也就是编码的过程；


反序列化：将byte[]转换成Java对象的过程；


可以使用Java原生的序列化机制，但是效率非常低，推荐使用一些开源的、成熟的序列化技术，例如：protobuf、Thrift、hessian、Kryo、Msgpack
关于序列化工具性能比较可以参考：jvm-serializers
3、NIO
当前很多RPC框架都直接基于netty这一IO通信框架，比如阿里巴巴的HSF、dubbo，Hadoop Avro，推荐使用Netty 作为底层通信框架。
4、服务注册中心
可选技术：


Redis


Zookeeper


Consul


Etcd


编程实践：手写实现千万级流量架构必备的RPC框架
视频内容

1、为什么千万级流量分布式、微服务架构都有RPC？

2、什么是RPC？

3、辨析RPC和HTTP

4、实现RPC框架我们需要解决哪些问题？

5、具体问题具体分析，各个解决和实现！

6、应付千万级流量，这样够了吗？反思我们的实现。

7、Dubbo和SpringCloud哪个更好？

Spring全套教学资料
Spring是Java程序员的《葵花宝典》，其中提供的各种大招，能简化我们的开发，大大提升开发效率！目前99%的公司使用了Spring，大家可以去各大招聘网站看一下，Spring算是必备技能，所以一定要掌握。
资料领取方式：点击这里前往蓝色传送门
目录：


部分内容：


Spring源码

第一部分 Spring 概述
第二部分 核心思想
第三部分 手写实现 IoC 和 AOP（自定义Spring框架）
第四部分 Spring IOC 高级应用

基础特性

高级特性
第五部分 Spring IOC源码深度剖析

设计优雅

设计模式

注意：原则、方法和技巧
第六部分 Spring AOP 应用

声明事务控制
第七部分 Spring AOP源码深度剖析

必要的笔记、必要的图、通俗易懂的语言化解知识难点



脚手框架：SpringBoot技术

它的目标是简化Spring应用和服务的创建、开发与部署，简化了配置文件，使用嵌入式web服务器，含有诸多开箱即用的微服务功能，可以和spring cloud联合部署。
Spring Boot的核心思想是约定大于配置，应用只需要很少的配置即可，简化了应用开发模式。


SpringBoot入门
配置文件
日志
Web开发
Docker
SpringBoot与数据访问
启动配置原理
自定义starter



微服务架构：Spring Cloud Alibaba

同 Spring Cloud 一样，Spring Cloud Alibaba 也是一套微服务解决方案，包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。


微服务架构介绍
Spring Cloud Alibaba介绍
微服务环境搭建
服务治理
服务容错
服务网关
链路追踪
ZipKin集成及数据持久化
消息驱动
短信服务
Nacos Confifig—服务配置
Seata—分布式事务
Dubbo—rpc通信



Spring MVC
目录：



部分内容：


m-1621576255570)]
[外链图片转存中…(img-2cNCHspY-1621576255571)]
[外链图片转存中…(img-AvZ4y84K-1621576255572)]
部分内容：
[外链图片转存中…(img-5D6wTpGe-1621576255572)]
[外链图片转存中…(img-zCzZ1dpH-1621576255573)]

至少登录和存款功能。

银行账户管理

方法:deposit: 存款方法withdraw:取款方法.

输入一个账户id（欲操作的用户账户）；
1.如果账户id不存在，输出提示信息
2.如果存在 ，显示账户信息 包括用户真实姓名和现有存款金额，进入存款和取款界面
3.用户输入1 进入存款操作，输入2 进入取款操作 ，0 退出账户登录
4.输入1进入存款界面后，输入要存的钱数，操作结束 显示存款信息，提示用户是否继续存款，输入1 继续存款 ，0 退出。
5.输入2 进入取款界面后，输入要取的钱数，余额不足的情况下，提示用户重新操作，操作结束后，显示取款信息，提示用户是否继续取款，1 继续取款 0 退出。
这里用了四个方法，可谓是方法套方法，也可移步至java小项目分栏去看我的java银行存取款2，那个是只用两种方法
package 存取钱;

import java.util.Scanner;

public class 哈哈哈哈 {
	static Scanner sc = new Scanner(System.in);
	static int[] iidd = {11,12,13,14};
	static String[] name = { "十一", "十二", "十三", "十四" };
	static double[] money = { 100, 200, 300, 400 };

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("欢迎登陆，请输入ID：");

		int id = sc.nextInt();
		yyzz(id);
		}
	
	private static void yyzz(int id) {
		// TODO Auto-generated method stub
		for (int i = 0; i < iidd.length; i++) {
			if (id == iidd[i]) {
				xinxi(i);

				}
		}
		System.out.println("您输入的ID不存在，请重新输入");
		
		main(null);
		}

	private static void xinxi(int i) {
		// TODO Auto-generated method stub
		System.out.println("欢迎" + name[i] + "登陆，你当前余额为：" + money[i]);
		System.out.println("输入1存钱 ，输入2取钱，输入0退出。请选择您的操作：");
		int q = sc.nextInt();
		switch (q) {
		case 1:
			deposit(i);
			break;
		case 2:
			withdraw(i);
			break;
		case 0:
			main(null);
			break;
		default:
			System.out.println("请输入1、2或0等有效数字");
			}
		}

	private static void withdraw(int i) {	
		// TODO Auto-generated method stub
		System.out.println("欢迎进入取款界面，请输入您要取出的金额：");
		double g = sc.nextDouble();
		if (money[i] > g) {
			money[i] = money[i] - g;
			System.out.println("您存入了" + g + "元,您当前的余额为：" + money[i]);
			} else {
			System.out.println("您的余额不足，无法取出！！");
			}

		System.out.println("输入1继续取款，输入0退出取款");
		int y = sc.nextInt();
		switch (y) {
		case 1:
			withdraw(i);
			break;
		case 0:
			main(null);
			break;

		}
		}

	private static void deposit(int i) {	
		// TODO Auto-generated method stub
		System.out.println("欢迎进入存款界面，请输入您要存入的金额：");
		double g = sc.nextDouble();
		money[i] = money[i] + g;
		System.out.println("您存入了" + g + "元,您当前的余额为：" + money[i]);
		System.out.println("输入1继续存钱，输入0退出存款");
		int y = sc.nextInt();
		switch (y) {
		case 1:
			deposit(i);
			break;
		case 0:
			main(null);
			break;
		}
		}
	}

关于线程同步，网上也有很多资料，不过不同的人理解也不大一样，最近在研究这个问题的时候回想起大学课本上的一个经典模型，即银行存取款模型，通过这个模型，我个人感觉解释起来还是比较清楚的。本文结合自己的思考对该模型进行一个简单的模拟，阐述一下我对线程同步的理解。

场景模拟

  接下来使用java对该问题进行模拟。在研究这个问题时会忽略掉现实系统中的很多其他属性(官网：www.fhadmin.org)，通过一个最简单的余额问题来看线程同步，这里首先创建三个类。

1.卡类，同时卡类提供三个方法，获取余额、存款以及取款。
public class Card {

    /*余额初始化*/
    private double balance;
    public Card(double balance){
        this.balance = balance;
    }

    /*获取余额方法*/
    public double Get_balance(){
        return this.balance;
    }

    /*存款方法*/
    public void deposit(double count) throws InterruptedException{
        System.out.println("存钱线程:存入金额=" + count);
        double now = balance + count;
        balance = now;
        System.out.println("存钱线程:当前金额=" + balance);
    }

    /*取款方法*/
    public void withdraw(double count) throws InterruptedException{
        System.out.println("取钱线程:取出金额=" + count);
        double now = balance - count;
        balance = now;
        System.out.println("取钱线程:当前金额=" + balance);
    }
}


然后是两个线程类，用于模拟并发操作所引入的余额问题。

2.存款线程类，存入金额100。
public class DepositThread extends Thread{
    private Card card;
    public DepositThread(Card card){
        this.card = card;
    }
    @Override
    public void run(){
        try {
            card.deposit(100);
        }
        catch(Exception e){System.out.println(e.toString());}
    }
}


3.取款线程类，取出金额50(官网：www.fhadmin.org)。
public class WithdrawThread extends Thread{
    private Card card;
    public WithdrawThread(Card card){
        this.card = card;
    }
    @Override
    public void run(){
        try {
            card.withdraw(50);
        }
        catch(Exception e){
            System.out.println(e.toString());
        }
    }
}


  现在先进行一个测试，让存款线程先进行存钱操作，然后取款线程进行取款，最后验证余额与逻辑是否符合。

测试代码如下：
public class CardTest{
    public static void main(String[] args) throws InterruptedException{
        Card card = new Card(100);
        System.out.println("操作前余额：" + card.Get_balance());
        DepositThread depositThread = new DepositThread(card);
        WithdrawThread withdrawThread = new WithdrawThread(card);
        depositThread.start();
        withdrawThread.start();
        Thread.sleep(2000);
        System.out.println("最终余额：" + card.Get_balance());
    }
}


运行后输出如下结果：


  现在大致的看一下，初始余额为100，然后存款线程存入100，接下来取款线程取走50，那么最后余额为150。这么看来，貌似没问题？

数据不一致问题

  事实上，存取款过程是需要消耗时间的(官网：www.fhadmin.org)，只要一个线程在操作余额期间受到其他线程的干扰，就可能出现数据不一致问题。这里我们修改存取款方法的代码如下。

存款方法：
    public void deposit(double count) throws InterruptedException{
        System.out.println("存钱线程:存入金额=" + count);
        double now = balance + count;
        Thread.sleep(100);  //存钱的操作用时0.1s
        balance = now;
        System.out.println("存钱线程:当前金额=" + balance);
    }


取款方法：
    public void withdraw(double count) throws InterruptedException{
        System.out.println("取钱线程:取出金额=" + count);
        double now = balance - count;
        Thread.sleep(200);  //取钱的操作用时0.2s
        balance = now;
        System.out.println("取钱线程:当前金额=" + balance);
    }
}


然后再运行一遍测试程序：


  现在，我们发现最终余额变成了50，这很显然是个完全不符合预期的错误结果。那么，如何来解释这个现象呢？


  从上图可以看到，出现数据不一致的原因在于多个线程并发访问了同一个对象，破坏了不可分割的操作，这里的这个共同访问对象就是余额。其实我们所谓预期的‘正确’结果，就是希望先进行存款，然后再进行取款，或者反之。

原子操作与锁

  上面提到‘不可分割的操作’，这种操作就是原子操作。是因为实际上多线程编程的情境下，很多敏感数据不允许被同时访问，因此对于这种针对敏感数据的操作，需要进行线程访问的协调与控制，这就是所谓的线程同步（协同步调）访问技术。线程同步控制的结果，就是把每次对敏感数据的操作变成原子操作，从而让执行顺序按照我们预期的过程进行。

  上述情境下，存款与取款应当是两个原子操作，我们必须保证先进行且完成存款操作再进行取款操作，才能保证最终数据的一致性，才能得到我们认为是‘正确’的结果。

下面我们通过锁来实现线程同步访问控制，修改Card类的代码如下。
public class Card {

    private double balance;
    private Object lock = new Object(); //锁

...省略其它代码

    /*存款*/
    public void deposit(double count) throws InterruptedException{
        System.out.println("存钱线程:存入金额=" + count);
        synchronized (lock) {
            double now = balance + count;
            Thread.sleep(100);//存钱的操作用时0.1s
            balance = now;
        }
        System.out.println("存钱线程:当前金额=" + balance);
    }

    /*取款*/
    public void withdraw(double count) throws InterruptedException{
        System.out.println("取钱线程:取出金额=" + count);
        synchronized (lock) {
            double now = balance - count;
            Thread.sleep(200);//取钱的操作用时0.2s
            balance = now;
        }
        System.out.println("取钱线程:当前金额=" + balance);
    }
}


运行结果如下：


  这段代码中，通过synchronized 关键字保证lock对象只能同时被一个线程访问，要想操作余额，那么必须先获取lock对象的访问许可，因此就保证了余额不会被多个线程同时修改，而最终的结果也完全符合我们的预期。这个lock对象就可以形象的理解成锁，整个执行过程大致如下图所示，

摘要:随着互联网的不断深入发展，网络早已改变了人们的购物方式和购物习惯，也改变了传统行业的服务平台，银行业早已融入到了互联网中，开发银行存取款业务管理系统可以使银行管理更高效更科学。
本课题通过结构化的系统分析方法，详细的讲解了一个银行存取款业务管理系统的编码、操作方式以及其它相关的核心技术。本课题首先是介绍了项目开发所依托的背景，其次是将所使用到jsp和Java技术做一个简单的介绍，方便读者理解；接下来便是系统的业务逻辑分析和业务逻辑的实现，按照银行的开发章程，先要提出具体的业务需求，然后开发人员对现有业务流程进行分析比较，再进行系统分析并完成数据字典；数据库的设计分别有概念结构设计，逻辑结构设计，以及数据库表设计，同时要考虑数据的安全性问题以及数据的持久性问题。在流程分析下，对整个银行管理系统进行全面的实现，待不断的SIT测试后，一个完善的管理系统便应运而生。
【关键词】银行存取款业务管理；结构化分析；JSP
目录
摘要
ABSTRACT
引    言-1
1 主要技术介绍-2
1.1 JSP技术-2
1.2 数据库技术-2
1.3 JAVA语言-2
1.4 开发框架介绍-3
2 系统分析-4
2.1 可行性分析-4
2.2 业务流程分析-5
2.3 数据流图-5
2.4 数据表示-7
3 系统设计-8
3.1 系统功能设计说明-8
3.2 数据库设计-9
3.3 数据库记录表-12
4 系统实现-12
4.1 管理员界面显示-12
4.2 用户界面显示-14
5 测试与分析-16
5.1 系统测试的重要性-16
5.2 对测试方法的研究-16
5.3 系统环境及测试结果-16
6 结论-17
参 考 文 献-18
附    录-19