数据表与简单java类的映射转换

基本操作:先抛开所有的关联字段,建立基本类,再引用关联表示关联关系

一对多映射

按照表的要求将表的结构转换为类的结构,同时获得如下信息:

  • 获取一个分类的信息
  • 可以根据分类获取对应的所有子分类的信息

package dataExcl;
class Item{
    private long iid;
    private String title;
    private Subitem subitems[];

    public Item(long iid, String title) {
        this.iid = iid;
        this.title = title;
    }

    public long getIid() {
        return iid;
    }

    public void setIid(long iid) {
        this.iid = iid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Subitem[] getSubitems() {
        return subitems;
    }

    public void setSubitems(Subitem[] subitems) {
        this.subitems = subitems;
    }

    public String getInfo(){
        return "分类信息:iid:"+this.iid+" title:"+this.title;
    }
}

class Subitem{
    private long sid ;
    private String title ;
    private Item items;

    public Subitem(long sid, String title) {
        this.sid = sid;
        this.title = title;
    }

    public long getSid() {
        return sid;
    }

    public void setSid(long sid) {
        this.sid = sid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Item getItems() {
        return items;
    }

    public void setItems(Item items) {
        this.items = items;
    }
        public String getInfo(){
            return "子分类信息:sid:"+this.sid+" title:"+this.title;
        }
}
public class JavaDemo {
    public static void main(String[] args) {
        //第一步:根据结构设置对象
        Item item = new Item(1L,"图书");
        Subitem subitem [] = new Subitem[]{
                new Subitem(10L,"编程图书"),
                new Subitem(10L,"图形图书")
        };
        item.setSubitems(subitem);
        for(int i=0;i<subitem.length;i++){
            subitem[i].setItems(item);
        }
        //第二部:根据要求获取数据
        System.out.println(item.getInfo());
        for(int i=0;i<subitem.length;i++){
            System.out.println(subitem[i].getInfo());
        }
    }
}
package dataExcl;
class Item{
    private long iid;
    private String title;
    private Subitem subitems[];

    public Item(long iid, String title) {
        this.iid = iid;
        this.title = title;
    }

    public long getIid() {
        return iid;
    }

    public void setIid(long iid) {
        this.iid = iid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Subitem[] getSubitems() {
        return subitems;
    }

    public void setSubitems(Subitem[] subitems) {
        this.subitems = subitems;
    }
}

class Subitem{
    private long sid ;
    private String title ;
    private Item items;

    public Subitem(long sid, String title) {
        this.sid = sid;
        this.title = title;
    }

    public long getSid() {
        return sid;
    }

    public void setSid(long sid) {
        this.sid = sid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Item getItems() {
        return items;
    }

    public void setItems(Item items) {
        this.items = items;
    }
}
public class JavaDemo {
    public static void main(String[] args) {
        //第一步:根据结构设置对象
        Item item = new Item(1L,"图书");
        Subitem subitem [] = new Subitem[]{
                new Subitem(10L,"编程图书"),
                new Subitem(10L,"图形图书")
        };
        item.setSubitems(subitem);
        for(int i=0;i<subitem.length;i++){
            System.out.println(subitem[i].getSid()+subitem[i].getTitle());
        }
        //第二部:根据要求获取数据

    }
}

多对多关系映射

将以上结构转换为类结构:

  • 获取一个用户访问的所有的商品信息
  • 获取一个商品被浏览过的所有信息

package dataExcl;
class User{
private long uid;
private String uname;
private Product product[];

public User(long uid, String uname) {
this.uid = uid;
this.uname = uname;
}

public Product[] getProduct() {
return product;
}

public void setProduct(Product[] product) {
this.product = product;
}

public String getInfo(){
return "[用户信息] 用户id:"+this.uid+"、用户id:"+this.uname;
}
}
class Product{
private long pnum;
private String pname;
private double price;
private User user[];

public Product(long pnum, String pname, double price) {
this.pnum = pnum;
this.pname = pname;
this.price = price;
}

public String getInfo(){
return "[商品信息] 商品编号:"+this.pnum+"、商品名称:"+this.pname+"、商品价格"+this.price;
}

public User[] getUser() {
return user;
}

public void setUser(User[] user) {
this.user = user;
}
}

public class JavaDemo {
public static void main(String[] args) {
//第一步:根据结构设置对象
User userA = new User(1L,"张三");
User userB = new User(2L,"李四");
User userC = new User(3L,"王五");

Product productA = new Product(1,"耳机",378.5);
Product productB = new Product(2,"电脑",6300.5);
Product productC = new Product(3,"音响",400);

userA.setProduct(new Product[]{productA,productB,productC});
userB.setProduct(new Product[]{productA,productB});
userC.setProduct(new Product[]{productA});

productA.setUser(new User[]{userA,userB,userC});
productB.setUser(new User[]{userA,userB});
productC.setUser(new User[]{userA});
//第二步:根据要求获取数据

System.out.println("------------------------根据用户查询访问信息----------------------------------");
System.out.println(userA.getInfo());
for (int i=0;i<userA.getProduct().length;i++){
System.out.println(userA.getProduct()[i].getInfo());
}
}
}

N2N内网穿透

和机友们玩儿红警,可是他们都是电信网络,而且对战平台只提供联通和电信专房,可怜自己是移动,就我一个玩儿不了,真的烦燥,于是乎Google一下有无方法解决这个局域网问题。虽然计网上边儿有讲Vlan这些技术,但是实际情况应用起来却是问题百出,接下来就谈一谈这次折腾的历程吧~~

首先是发现了一篇论文,在翻译了阅读了一遍后,进行了如下实验。毕竟东西都是现成,所以搭建的功夫应该很快,后边儿详细说一些遇到的坑。

  • 边缘节点与超级节点之间通过n2n进行连接,超级节点实现流量处理,相当于边缘节点之间在局域网内
  • 超级节点与边缘节点之间传输udp
  • 防火墙开端口,边缘节点防火墙开端口
  1. 建立超级节点
  2. 立边缘节点

谈一点儿打游戏的乌龙吧。

RedAlert 共和国之辉,已经穿透了NAT,按理说应该是选择在线ip后可以通过虚拟网卡,以局域网的形式发现才对啊!可是就是不行??为啥啊!!明明都可以在电脑上局域网内发现,可是为啥??

知道我去当天下午更新中国式家长的时候,我发现了一个问题,会不会是版本的原因??难道传输的东西不是通过udp方式的??

于是忽我去防火墙看了一波,udp被仅用了,打开呢?没效果!!然后去Google看了一波,共和国之辉只支持Tcp,udp不支持了啊,不知道是不是这个原因,反正最后想要在自己服务器上打打局域网游戏也没有成功,就不了了之了啊~~

Wireshark实验

一、分组嗅探器

所谓数据抓包,实际上是复制TCP / IP的数据链路层中接收或发送的以太网帧(以太网帧),因为所有上层协议最终都已经封装在以太网帧中了

二、wirshark折腾

Networking 第一个实验,查看报文序列等,emmm~~host是当前博客网站服务器啦就,就简单完成第一个实验。

docker学习(2)

一、Container(容器部分)

define a container——Dockerfile

一段儿官方的定义是这样: Dockerfile defines what goes on in the environment inside your container. Access to resources like networking interfaces and disk drives is virtualized inside this environment, which is isolated from the rest of your system, so you need to map ports to the outside world, and be specific about what files you want to “copy in” to that environment. However, after doing that, you can expect that the build of your app defined in this Dockerfile behaves exactly the same wherever it runs.

emmmm~两层意思,1、dockerfile定义容器内部环境发生的事情;2、对网络接口和磁盘驱动等资源的访问在此环境内进行虚拟化,与系统其余部分隔离(因此需要进行端口映射到外部环境,还要具体说明复制到的文件环境)

格式:

步骤一、先创建一个空文件夹,再touch一个Dockefile

步骤二、Dockerfile内容如下

FROM 【image】

RUN (或者其他动作)

步骤三、docker build – < Dockerfile(我习惯从标准输入流进行build)

二、service部分(服务部分)

define a service——docker-compose.yml

docker学习(1)

首先给一个docker的文档连接,便于复习文档,emmmm自顶向下吧,先学会咋用它,再去理解每个步骤发生了什么,慢慢补充深入。

一、docker Start

docker ps——查看docker正在运行的进程

Container stack example
Virtual machine stack example

区分一下VMware和Docker之间的区别,从上图可以理解,docker并没有直接建立OS,而是单独运行容器,这样的话占用资源就会更少,起的容器可以更多

二、docker安装

官网上有docker的安装教程,下边儿是对于docker代理的学习,为什么要代理了?

首先国内的资源的话虽然很快,很便捷,但是呢?你品,你细品,肯定没有国外的官网的内容更原滋原味啊,而且万一更新时间滞后,导致版本混乱或者什么的,到时候岂不是废了,所以有必要代理。

步骤1、为docker创建服务创建一个内嵌的systemd目录

$ mkdir -p /etc/systemd/system/docker.service.d

步骤2、 创建/etc/systemd/system/docker.service.d/http-proxy.conf文件,并添加HTTP_PROXY环境变量。其中[proxy-addr]和[proxy-port]分别改成实际情况的代理地址和端口:

[Service]
Environment=”HTTP_PROXY=http://[proxy-addr]:[proxy-port]/”

“HTTPS_PROXY=https://[proxy-addr]:[proxy-port]/”

步骤3、 如果还有内部的不需要使用代理来访问的Docker registries,还需要制定NO_PROXY环境变量:

[Service]
Environment=”HTTP_PROXY=http://[proxy-addr]:[proxy-port]/”

“HTTPS_PROXY=https://[proxy-addr]:[proxy-port]/” “NO_PROXY=localhost,127.0.0.1,docker-registry.somecorporation.com”

步骤4、更新配置

$ systemctl daemon-reload

步骤5、重启docker服务

$ systemctl restart docker

三、docker Test的一些基本操作

1、Test docker version——docker –version

2、more information——docker info(docker version)

四、docker Test installation

1、docker run hello-world

2、docekr image ls——查看images

3、docker container ls –all——显示container的详细信息

NginX学习(2)

1、nginx架构——内部怎么做的

Nginx 在启动后,会有一个 master 进程和多个 worker 进程。

master 进程主要用来管理 worker 进程,包含:接收来自外界的信号,向各 worker 进程发送信号,监控 worker 进程的运行状态,当 worker 进程退出后(异常情况下),会自动重新启动新的 worker 进程。而基本的网络事件,则是放在 worker 进程中来处理了。

多个 worker 进程之间是对等的,他们同等竞争来自客户端的请求,各进程互相之间是独立的。

一个请求,只可能在一个 worker 进程中处理,一个 worker 进程,不可能处理其它进程的请求。

worker 进程的个数是可以设置的,一般我们会设置与机器cpu核数一致,这里面的原因与 Nginx 的进程模型以及事件处理模型是分不开的

2、worker进程处理请求

当我们提供 80 端口的 http 服务时,一个连接请求过来,每个进程都有可能处理这个连接,怎么做到的呢?

首先,每个 worker 进程都是从 master 进程 fork 过来,在 master 进程里面,先建立好需要 listen 的 socket(listenfd)之后,然后再 fork 出多个 worker 进程。

所有 worker 进程的 listenfd 会在新连接到来时变得可读,为保证只有一个进程处理该连接,所有 worker 进程在注册 listenfd 读事件前抢 accept_mutex,抢到互斥锁的那个进程注册 listenfd 读事件,在读事件里调用 accept 接受该连接。

当一个 worker 进程在 accept 这个连接之后,就开始读取请求,解析请求,处理请求,产生数据后,再返回给客户端,最后才断开连接,这样一个完整的请求就是这样的了。我们可以看到,一个请求,完全由 worker 进程来处理,而且只在一个 worker 进程中处理。

3、异步非阻塞处理方式(好深奥的感觉)

NginX学习(1)

NginX特点——不一定全部理解(标记)

  • 处理静态文件,索引文件以及自动索引;打开文件描述符缓冲.
  • 无缓存的反向代理加速,简单的负载均衡和容错.
  • FastCGI,简单的负载均衡和容错.
  • 模块化的结构。包括 gzipping, byte ranges, chunked responses,以及 SSI-filter 等 filter。如果由 FastCGI 或其它代理服务器处理单页中存在的多个 SSI,则这项处理可以并行运行,而不需要相互等待。
  • 支持 SSL 和 TLSSNI.

1、性能优化——高并发,支持Poll模型

(积累一个知识点儿:IO多路复用

IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取,它就通知该进程。 与多进程和多线程技术相比,I/O多路复用技术的最大优势是系统开销小,系统不必创建进程/线程,也不必维护这些进程/线程,从而大大减小了系统的开销。

2、稳定性—— 分阶段资源分配技术,使得它的 CPU 与内存占用率非常低

3、支持热部署

4、Nginx 采用 master-slave 模型,能够充分利用 SMP 的优势,且能够减少工作进程在磁盘 I/O 的阻塞延迟。当采用 select()/poll() 调用时,还可以限制每个进程的连接数。

5、 代码质量高,模块扩展也很容易