package zhangphil.nettysender;

import java.io.DataInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.Date;
import java.text.SimpleDateFormat;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.json.JsonObjectDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class App {
	private int SERVER_PORT = 20000;

	public App() throws Exception {
		new Server().start();
		connectServer();
	}

	// Netty作为客户端，发起对服务器端的连接请求。
	private void connectServer() {
		EventLoopGroup group = new NioEventLoopGroup();// 设置的连接group。
		Bootstrap bootstrap = new Bootstrap().group(group).option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000) // 超时时间。
				.channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
					@Override
					public void initChannel(SocketChannel ch) throws Exception {
						ch.pipeline().addLast(new JsonObjectDecoder());
						ch.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));// String解码。
						ch.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));// String解码。

						ch.pipeline().addLast(new MyChannelHandlerAdapter());//
					}
				});

		try {
			System.out.println("客户端连接服务器...");
			ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", SERVER_PORT)
					.addListener(new ChannelFutureListener() {
						public void operationComplete(ChannelFuture future) throws Exception {
							if (future.isSuccess()) {
								// 第一种方法。
								// Netty在这里发送数据。
								// sendDataToServer(future.channel());
							}
						}
					}).sync();

			// 等待连接关闭。
			channelFuture.channel().closeFuture().sync();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 发送数据到服务器端。
	 * 
	 * @throws Exception
	 */
	private void sendDataToServer(Channel channel) throws Exception {
		Date date = new Date(System.currentTimeMillis());
		SimpleDateFormat sdf = new SimpleDateFormat("MM-dd,HH:mm:ss:SSS");

		while (true) {
			date.setTime(System.currentTimeMillis());
			channel.writeAndFlush("客户端@" + sdf.format(date));
			System.out.println("客户端发送数据:" + sdf.format(date));

			Thread.sleep(1000);
		}
	}

	private class MyChannelHandlerAdapter extends ChannelHandlerAdapter {
		// 连接激活。
		@Override
		public void channelActive(ChannelHandlerContext ctx) throws Exception {
			super.channelActive(ctx);
			System.out.println("channelActive:" + ctx.channel().remoteAddress());

			// 第二种方法。
			// 连接可用激活后，Netty开始往服务器端发送数据。
			sendDataToServer(ctx.channel());
		}

		@Override
		public void channelInactive(ChannelHandlerContext ctx) throws Exception {
			super.channelInactive(ctx);
			System.out.println("channelInactive:" + ctx.channel().remoteAddress());
		}

		@Override
		public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
			super.channelRead(ctx, msg);
		}

		@Override
		public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
			super.channelReadComplete(ctx);
			System.out.println(ctx.channel().remoteAddress() + "读写完成");
		}
	}

	public static void main(String[] args) {
		try {
			new App();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 服务器端。演示作为服务器接受来自客户端的数据。
	private class Server extends Thread {
		private ServerSocket serverSocket;

		public Server() throws Exception {
			serverSocket = new ServerSocket(SERVER_PORT);
		}

		@Override
		public void run() {
			try {
				System.out.println("服务器启动...");
				Socket socket = serverSocket.accept();
				System.out.println("服务器接受连接");

				DataInputStream dis = new DataInputStream(socket.getInputStream());

				byte[] buffer = new byte[256];
				int c = 0;
				while (true) {
					c = dis.read(buffer);
					System.out.println("服务器端收到数据:" + new String(buffer, 0, c));
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

总过程

第一阶段: 客户端发送请求 通过DNS解析找到具体的ip地址和端口号
第二阶段: webserver(Tomca中间件)----->DispatcherServlet
第三阶段:springmvc处理请,求并响应结果返还给客户端

第一阶段 :DNS映射

具体什么是DNS？

DNS( Domain Name System)是“域名系统”的英文缩写，是一种组织成域层次结构的计算机和网络服务命名系统，它用于TCP/IP网络，它所提供的服务是用来将主机名和域名转换为IP地址的工作。DNS就是这样的一位“翻译官”，有人说DNS就是一个本大得电话本，说的也挺贴切 它的基本工作原理可用下图来表示。

Dns服务的工作过程

我们在浏览器访问www.baidu.com这个域名，dns怎么查询到这台主机那？

1、在浏览器中输入www.baidu.com域名，操作系统会先检查自己本地的hosts文件是否有这个网址映射关系，如果有，就先调用这个ip地址映射，完成域名解析。

2、如果hosts里没有这个域名的映射，则会查找本地DNS解析器缓存，是否有这个网址映射关系，如果有，直接返回，完成域名解析。

3、如果hosts与本地DNS解析器缓存都没有相应的网址映射关系，首先会找TCP/IP参数中设置的首选DNS服务器，在此我们叫它本地DNS服务器，此服务器收到查询时，如果要查询的域名，包含在本地配置区域资源中，则返回解析记过给客户端，完成域名解析，此解析具有权威性。

4、如果要查询域名，不由本地DNS服务器区域解析，但该服务器已缓存了此网址映射关系，则调用这个IP地址映射，完成域名解析，此解析不具有权威性。

5、如果本地DNS服务器本地区域文件与缓存解析都失效，则根据本地DNS服务器的设置（是否设置转发器）进行查询，如果未用转发模式，本地DNS就把请求发至13台根DNS，根DNS服务器收到请求后会判断这个域名（.com）是谁来授权管理，并会返回一个负责该顶级域名服务器的一个IP。本地DNS服务器收到IP信息后，将会联系负责.com域的这台服务器。这台负责.com域的服务器收到请求后，如果自己无法解析，它就会找一个管理.com域的下一级DNS服务器地址（baidu.com）给本地DNS服务器。当本地DNS服务器收到这个地址后，就会找baidu.com域服务器，重复上面的动作，进行查询，直至找到www.baidu.com主机。

6、如果用的是转发模式，此DNS服务器就会把请求转发至上一级DNS服务器，由上一级服务器进行解析，上一级服务器如果不能解析，或找根DNS或把请求转至上上级，以此循环。不管是本地DNS服务器用是转发，还是根提示，最后都是把结果返回给本地DNS服务器，由此DNS服务器再返回给客户机。

DNS域名

第二阶段: webserver(Tomca中间件)----->DispatcherServlet

客户端访问网址,服务器端页面响应 --------通过sts断点分析

1.初始化会开启一些守护线程

2.线程池 取出相关线程处理请求

3.io流读取 socket 封装的HTTP请求数据

4服务器会调用Servlet中的service方法,把浏览器发送给服务器的请求信息信息封装到Request对象中

5.过滤器filter
6.DispatcherServlet前端控制器

第三阶段:springmvc处理请求,并响应结果返还给客户端

springmvc执行原理
(1).用户发送请求 至 前端控制器(DispatcherServlet)；
提示：DispatcherServlet的作用：接收请求，调用其它组件处理请求，响应结果，相当于转发器、中央处理器，是整个流程控制的中心

(2).前端控制器(DispatcherServlet)收到请求后调用处理器映射器(HandlerMapping)
处理器映射器(HandlerMapping)找到具体的Controller(可以根据xml配置、注解进行查找)，并将Controller返回给DispatcherServlet；

(3).前端控制器(DispatcherServlet)调用处理器适配器(HandlerAdapter)。处理器适配器经过适配调用具体的Controller；(Controller–> service --> Dao --> 数据库)
Controller执行完成后返回ModelAndView，
提示：Model(模型数据，即Controller处理的结果，Map) View(逻辑视图名，即负责展示结果的JSP页面的名字)
处理器适配器(HandlerAdapter)将controller执行的结果(ModelAndView)返回给前端控制器(DispatcherServlet)；

(4).前端控制器(DispatcherServlet)将执行的结果(ModelAndView)传给视图解析器(ViewReslover)
视图解析器(ViewReslover)根据View(逻辑视图名)解析后返回具体JSP页面

(5).前端控制器(DispatcherServlet)根据Model对View进行渲染（即将模型数据填充至视图中）；
前端控制器(DispatcherServlet)将填充了数据的网页响应给用户。
其中整个过程中需要开发人员编写的部分有Controller、Service、Dao、View；

SpringMVC执行详解

1. 在SpringMVC框架启动之初,程序会对处理器映射器(HandlerMapping)的进行实例化,其中处理器映射器(HandlerMapping)中会有一个map的结构类型.其中map中的key存储的是你要拦截请求路径,value存储的是你要具体要执行的请求方法.
   所以在SpringMVC框架启动之初,处理器映射器(HandlerMapping)会把所有请求的注解,和他标识的相关方法进行统一的记录.
2. 如果有用户发来请求,首先会被前端控制器(DispatcherServlet所拦截,前端控制器(DispatcherServlet)收到请求后调用处理器映射器(HandlerMapping),通过相关路径匹配,找到具体的Controller(可以根据xml配)，并将Controller返回给DispatcherServlet；
3. 前端控制器(DispatcherServlet)调用处理器适配器(HandlerAdapter)。处理器适配器根据你标识的注解,调用相对应的handler处理器,由这个handler处理器来做具体的调用.Controller；(Controller–>service --> Dao --> 数据库) 最后将controller执行的结果(ModelAndView)对象返回给前端控制器(DispatcherServlet)；
4. 前端控制器(DispatcherServlet)将执行的结果(ModelAndView)传给视图解析器(ViewReslover)视图解析器(ViewReslover)根据View(逻辑视图名)解析后返回具体JSP页面
5. 前端控制器(DispatcherServlet)根据Model对View进行渲染（即将模型数据填充至视图中）； 前端控制器(DispatcherServlet)将填充了数据的网页响应给用户。

Spring MVC中的拦截器

Spring MVC中的拦截器基于回调机制，可以在目标方法执行之前，先进行业务检测，满足条件则放行，不满足条件则进行拦截，拦截器原理分析如下图所示：

SpringMVC拦截器工作原理

HandlerInterceptor

案例

HandlerInterceptor 拦截器

@Component  //spring容器管理对象
public class UserInterceptor implements HandlerInterceptor {

    @Autowired
    private JedisCluster jedisCluster;

    //Spring版本升级 4 必须实现所有的方法  spring 5 只需要重写指定的方法即可.

    /**
     * 需求:   拦截/cart开头的所有的请求进行拦截.,并且校验用户是否登录.....
     * 拦截器选择: preHandler
     * 如何判断用户是否登录:  1.检查cookie信息   2.检查Redis中是否有记录.
     *          true : 请求应该放行
     *          false: 请求应该拦截 则配合重定向的语法实现页面跳转到登录页面 使得程序流转起来

     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.判断用户是否登录  检查cookie是否有值
        String ticket = CookieUtil.getCookieValue(request,"JT_TICKET");
        //2.校验ticket
        if(!StringUtils.isEmpty(ticket)){
            //3.判断redis中是否有值.
            if(jedisCluster.exists(ticket)){
                //4.动态获取json信息
                String userJSON = jedisCluster.get(ticket);
                User user = ObjectMapperUtil.toObj(userJSON,User.class);
                request.setAttribute("JT_USER",user);
                return true;
            }
        }
        response.sendRedirect("/user/login.html");
        return false;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //销毁数据
        request.removeAttribute("JT_USER");
    }
}

WebMvcConfigurer— springmvc 配置类

@Configuration
public class MvcConfigurer implements WebMvcConfigurer{
	


	//添加拦截器
	@Autowired
	private UserInterceptor userInterceptor;

	@Override
	public void addInterceptors(InterceptorRegistry registry) {

		registry.addInterceptor(userInterceptor).addPathPatterns("/cart/**","/order/**");

	}

}

各种拦截器Filer

另:servlet回顾

Servlet本质

Servlet本质是一段运行在服务器端的Java程序，

和之前的Java程序不同的是，Servlet程序无法独立运行，需要将Servlet程序放在服务器中（比如tomcat服务器），由服务器调用才可以执行。
SpringMVC基于Servlet进行封装的框架

servlet的生命周期

1.加载和实例化
2.初始化
3.请求处理
4.服务终止

Web服务器在与客户端交互时Servlet的工作过程是:

1. 在客户端对web服务器发出请求
2. web服务器接收到请求后将其发送给Servlet
3. Servlet容器为此产生一个实例对象并调用ServletAPI中相应的方法来对客户端HTTP请求进行处理,然后将处理的响应结果返回给WEB服务器.
4. web服务器将从Servlet实例对象中收到的响应结构发送回客户端.
   当浏览器发请求访问服务器中的某一个Servlet时，服务器将会调用Servlet中的service方法来处理请求。在调用service方法之前会创建出request和response对象。

request和response

其中request对象中封装了浏览器发送给服务器的请求信息（请求行、请求头、请求实体等），
response对象中将会封装服务器要发送给浏览器的响应信息（状态行、响应头、响应实体），在service方法执行完后，服务器再将response中的数据取出，按照HTTP协议的格式发送给浏览器。

每次浏览器访问服务器，服务器在调用service方法处理请求之前都会创建request和response对象。（即，服务器每次处理请求都会创建request和response对象）

在请求处理完，响应结束时，服务器会销毁request和response对象。