精华内容
下载资源
问答
  • 手写Tomcat框架

    2019-11-25 22:20:30
    实现了一个简单的Tomcat框架,模拟了Tomcat框架中处理浏览器请求Servlet最基础的功能。
  • 下载下来,项目名称想改可以改(记得还要改pom里的项目名称),不改也没事,框架里面有普通的查询功能,不要也可以删除。我用的tomcat8+jdk1.8
  • Tomcat框架包32版本

    2019-03-11 21:57:31
    Tomcat框架包32版本
  • Spring如何与Tomcat框架进行集成

    千次阅读 2019-07-20 07:30:00
    一、前言本节我们讲究如何利用Tomcat的ContextLoaderListener扩展接口来把Spring框架Tomcat进行连接起来。二、ContextLoader...

    一、前言

    本节我们讲究如何利用Tomcat的ContextLoaderListener扩展接口来把Spring框架与Tomcat进行连接起来。

    二、ContextLoaderListener扩展接口

    ContextLoaderListener一般用来启动一个Spring容器或者框架的根容器,例如Webx框架的WebxContextLoaderListener就是继承该类,实现了webx框架到Tomcat容器的衔接点,而SpringMVC则通过在ContextLoaderListener启动一个IOC来管理bo类的bean,下面首先看下ContextLoaderListener的类图结构:640?wx_fmt=png可知ContextLoaderListener的两个方法都是含有一个ServletContextEvent类型的参数。

    那么这个ContextLoaderListener一般是怎么使用的那?ContextLoaderListener一般是按照下面的方式配置到web.xml里面:640?wx_fmt=png

    如上代码,首先创建了一个ContextLoaderListener实例,该实例会创建一个XmlWebApplicationContext应用程序上下文,contextConfigLocation是要告诉ContextLoaderListener要把哪些Bean注入到XmlWebApplicationContext管理的BeanFactory。

    这里首先有几个问题,比如配置的全局的contextConfigLocation属性是怎么在ContextLoaderListener中获取的?ContextLoaderListener与Tomcat是什么关系那?ContextLoaderListener是如何创建的XmlWebApplicationContext?

    为了解开前两个问题,我们需要看下Tomcat(本文tomcat版本为 apache-tomcat-8.5.12)中的一些代码时序图640?wx_fmt=png

    • 在Tomcat中一个StandardContext代表者一个Web应用,时序图中步骤(2)(3)在Web应用启动过程中会调用mergeParameters方法解析web.xml配置的context-param参数,并把这些参数设置到ApplicationContext中,也就是说上面配置的contextConfigLocation参数和值也保存到了ApplicationContext中,需要注意的是这里的ApplicationContext不同于Spring框架中的ApplicationContext,这里的ApplicationContext是tomcat中的ApplicationContext ,它实现了 org.apache.catalina.servlet4preview.ServletContext,是一个ServletContext,这个ApplicationContext是应用级别的,每个应用维护着自己的一个ApplicationContext对象,用来保存应用级别的变量信息,其内部通过 privatefinalConcurrentMap<String,String>parameters=newConcurrentHashMap<>();保存应用级别的变量信息。

    • 时序图中步骤(4)(5)(6)是初始化所有在web.xml里面配置的ServletContextListener的实现类,并以ApplicationContext为构造函数参数创建一个ServletContextEvent 作为ServletContext事件(内部实际维护的是ApplicationContext的一个门面类ApplicationContextFacade),然后调用所有实现类的contextInitialized的方法并传递ServletContextEvent作为参数,至此解开了ContextLoaderListener与Tomcat的关系,也就是说在tomcat的每个应用启动过程中会调用ContextLoaderListener的contextInitialized方法并且传递的参数里面包含该应用级别的一个ApplicationContext对象,该对象里面包含了该应用的全局作用域的变量集合。

    下面看下ContextLoaderListener的contextInitialized方法时序图,看是如何创建XmlWebApplicationContext并获取到了contextConfigLocation变量的值作为Spring容器加载Bean的数据源:

    640?wx_fmt=png

    • 如上时序图步骤(3)创建Spring应用程序上下文XmlWebApplicationContext

    • 如上时序图步骤(5)设置XmlWebApplicationContext的ServletContext为ApplicationContextFacade

    • 如上时序图步骤(6)(7)从ServletContext中获取contextConfigLocation变量的值,这里为WEB-INF/applicationContext.xml

    • 如上时序图步骤(8)设置XmlWebApplicationContext的配置文件为WEB-INF/applicationContext.xml,这意味着会从WEB-INF/applicationContext.xml中解析Bean注入到XmlWebApplicationContext管理的BeanFactory。

    • 如上时序图步骤(9)刷新XmlWebApplicationContext应用程序上下文

    • 如上时序图步骤(10)保存XmlWebApplicationContext到ServletContext,这样应用里面任何有ServletContext的地方就可以获取XmlWebApplicationContext,从而可以获取XmlWebApplicationContext管理的所有Bean。

    三、 SpringMVC与Tomcat容器的衔接点

    SpringMvc是目前使用非常频繁的框架,springmvc里面经常会使用两级级联容器,并且每层容器都各有用途,使用过SpringMVC的童鞋都知道,一般我们在web.xml里面会配置一个listener和一个dispatcher,其实这就配置了两个spring IOC容器,并且dispatcher容器的父容器就是listener的容器。一般在web.xml里面配置如下:

    &lt;listener&gt;	
        &lt;listener-class&gt;org.springframework.web.context.ContextLoaderListener&lt;/listener-class&gt;	
    &lt;/listener&gt;	
    &lt;context-param&gt;	
        &lt;param-name&gt;contextConfigLocation&lt;/param-name&gt;	
        &lt;param-value&gt;WEB-INF/applicationContext.xml&lt;/param-value&gt;	
    &lt;/context-param&gt;
    &lt;servlet&gt;	
        &lt;servlet-name&gt;springmvc&lt;/servlet-name&gt;	
        &lt;servlet-class&gt;org.springframework.web.servlet.DispatcherServlet&lt;/servlet-class&gt;	
        &lt;load-on-startup&gt;1&lt;/load-on-startup&gt;	
    &lt;/servlet&gt;

    其中ContextLoaderListener会创建一个XMLWebApplicationContext上下文来管理contextConfigLocation配置的xml里面的普通bean,这个上节已经讲过。

    DispatcherServlet也会创建一个XMLWebApplicationContext默认管理web-info/springmvc-servlet.xml里面的Controller bean,下面看下创建的流程时序图:640?wx_fmt=png

    如图在DispatcherServlet的初始化方法中首先从ServletContext的全局变量表里面获取ContextLoaderListener创建的XMLWebApplicationContext上下文,然后使用该context作为父上下文创建了SpringMVC的servlet的context容器,并且设置namespace为springmvc-servlet,这个在查找配置文件时候用到,最后会拼接为springmvc-servlet.xml,最后刷新SpringMVC的servlet的context上下文。

    一般我们在listener创建的父容器里面配置bo类用来具体操作业务,在dispatcher子容器里面配的Controller类,然后Controller里面具体调用bo类来实现业务。

    至此结合上节通过Tomcat启动过程中调用ContextLoaderListener的contextInitialized方法首先创建了父容器用来管理bo bean,然后使用DispatcherServlet创建了子容器用来管理Controller bean ,ContextLoaderListener让SpringMVC与Tomcat容器联系起来了。

    四、参考

    • https://docs.spring.io/spring/docs/4.3.13.RELEASE/spring-framework-reference/html/beans.html

    • https://docs.spring.io/spring/docs/4.3.13.RELEASE/spring-framework-reference/html/beans.html#beans-factory-extension

    展开全文
  • SpringBoot使用Netty替换tomcat框架

    千次阅读 2019-12-18 18:50:26
    1、创建SpringBoot项目-主启动类如下(NettyHandler是自定义注解,稍后会放出) @SpringBootApplication @ComponentScan(includeFilters = @ComponentScan.Filter(NettyHandler.class)) public class ...
    • 1、创建SpringBoot项目-主启动类如下(NettyHandler是自定义注解,稍后会放出)
    @SpringBootApplication
    @ComponentScan(includeFilters = @ComponentScan.Filter(NettyHandler.class))
    public class DemoMainApplication {
    
        public static void main(String[] args) {
            new SpringApplicationBuilder(DemoMainApplication.class).web(WebApplicationType.NONE).run(args);
        }
    }
    
    • 2、创建NettyHandler自定义注解
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Mapping
    public @interface  NettyHandler {
    
        @AliasFor("path")
        String[] value() default {};
    
        String name() default "";
    
        RequestMethod[] method() default {};
    
        @AliasFor("value")
        String[] path() default {};
    
    }
    
    • 3、创建Netty服务端
    @Configuration
    public class NettyServer implements ApplicationListener<ApplicationStartedEvent> {
    
        private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);
    
    
        private int port = 8080;
    
    
        @Override
        public void onApplicationEvent(@NonNull ApplicationStartedEvent event) {
            ServerBootstrap bootstrap = new ServerBootstrap();
            EventLoopGroup bossGroup = new NioEventLoopGroup();
            EventLoopGroup workerGroup = new NioEventLoopGroup();
            ChannelFuture channelFuture = null;
            try {
                bootstrap.group(bossGroup, workerGroup);
                channelFuture =  bootstrap.channel(NioServerSocketChannel.class)
                        .childHandler(new InitServerHandler())
                        .bind(port).syncUninterruptibly().addListener(future -> {
                            String loginfo = "Netty 启动成功!端口=" + port;
                            logger.info(loginfo);
                        });
            }catch (Exception e) {
    
            } finally {
                channelFuture.channel().closeFuture().addListener(future -> {
                    bossGroup.shutdownGracefully();
                    workerGroup.shutdownGracefully();
                });
            }
    
        }
    }
    
    • 4、创建 InitServerHandler(HttpServerHandler 为业务处理类)
    public class InitServerHandler extends ChannelInitializer<SocketChannel> {
    
        @Override
        protected void initChannel(SocketChannel ch) {
            ch.pipeline().addLast("http-decoder",new HttpRequestDecoder());
            ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(Integer.MAX_VALUE));
            ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
            ch.pipeline().addLast("http-server", new HttpServerHandler());
        }
    }
    
    • 5、创建业务处理类(setApplicationContext根据业务需求进行改造)
    @ChannelHandler.Sharable
    @Component
    public class HttpServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> implements ApplicationContextAware {
    
    
        private static ConcurrentHashMap<String ,HashMap<String, String>> concurrentHashMap = new ConcurrentHashMap<String, HashMap<String, String>>();
    
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
    		//TODO 处理业务
      		System.out.println("业务处理");
            ctx.writeAndFlush(request).addListener(ChannelFutureListener.CLOSE);
    
        }
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    
            Map<String, Object> handlers = applicationContext.getBeansWithAnnotation(NettyHandler.class);
            for (Map.Entry<String, Object> entry : handlers.entrySet()) {
                Object handler = entry.getValue();
                for (Method method : handler.getClass().getMethods())
                {
                    Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
                    for (Annotation ann:declaredAnnotations)
                    {
                        if(ann.annotationType().getName().equals(NettyHandler.class.getName()))
                        {
                            String[] value = method.getAnnotation(NettyHandler.class).value();
                            if(value != null)
                            {
                                for (String uri:value)
                                {
                                    uri = uri.replace("/","");
                                    HashMap<String, String> submap = new HashMap<String, String>();
                                    submap.put(method.getName(),handler.getClass().getName());
                                    concurrentHashMap.put(uri, submap);
                                }
                            }
                        }
                    }
                }
            }
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            ctx.fireExceptionCaught(cause);
        }
    
    }
    
    展开全文
  • 基于jsp+MySQL+tomcat框架的一个简单博客,非常的简明.
  • 解析TOMCAT框架

    千次阅读 2012-04-09 14:46:43
    毕竟TOMCAT框架还是比较复杂的, 单是从文字上理解, 是不那么容易掌握TOMCAT框架的。 所以得实践、实践、再实践。 建议下载一份TOMCAT的源码, 调试通过, 然后单步跟踪其启动过程。 如果有不明白的地方, 再来...
       

    毕竟TOMCAT的框架还是比较复杂的, 单是从文字上理解, 是不那么容易掌握TOMCAT的框架的。 所以得实践、实践、再实践。 建议下载一份TOMCAT的源码, 调试通过, 然后单步跟踪其启动过程。 如果有不明白的地方, 再来查阅本文, 看是否能得到帮助。 我相信这样效果以及学习速度都会好很多!
      
    1. Tomcat的整体框架结构
       Tomcat的基本框架, 分为4个层次。
       Top Level Elements:
        Server
        Service  
       Connector
        HTTP
        AJP
       Container
       Engine
         Host
       Context
       Component 
        manager
       logger
       loader
       pipeline
       valve
             ...
       站在框架的顶层的是Server和Service
       Server:  其实就是BackGroud程序, 在Tomcat里面的Server的用处是启动和监听服务端事件(诸如重启、关闭等命令。 在tomcat的标准配置文件:server.xml里面, 我们可以看到“<Server port="8005" shutdown="SHUTDOWN" debug="0">”这里的"SHUTDOWN"就是server在监听服务端事件的时候所使用的命令字)
       Service: 在tomcat里面, service是指一类问题的解决方案。  通常我们会默认使用tomcat提供的:Tomcat-Standalone 模式的service。 在这种方式下的service既给我们提供解析jsp和servlet的服务, 同时也提供给我们解析静态文本的服务。
      
       Connector: Tomcat都是在容器里面处理问题的, 而容器又到哪里去取得输入信息呢?
    Connector就是专干这个的。 他会把从socket传递过来的数据, 封装成Request, 传递给容器来处理。
       通常我们会用到两种Connector,一种叫http connectoer, 用来传递http需求的。 另一种叫AJP, 在我们整合apache与tomcat工作的时候, apache与tomcat之间就是通过这个协议来互动的。 (说到apache与tomcat的整合工作, 通常我们的目的是为了让apache 获取静态资源, 而让tomcat来解析动态的jsp或者servlet。)
       Container: 当http connector把需求传递给顶级的container: Engin的时候, 我们的视线就应该移动到Container这个层面来了。
       在Container这个层, 我们包含了3种容器: Engin, Host, Context.
       Engin: 收到service传递过来的需求, 处理后, 将结果返回给service( service 是通过 connector 这个媒介来和Engin互动的 ).
       Host: Engin收到service传递过来的需求后,不会自己处理, 而是交给合适的Host来处理。
    Host在这里就是虚拟主机的意思, 通常我们都只会使用一个主机,既“localhost”本地机来处理。
       Context: Host接到了从Host传过来的需求后, 也不会自己处理, 而是交给合适的Context来处理。
       比如: <http://127.0.0.1:8080/foo/index.jsp>
             <http://127.0.1:8080/bar/index.jsp>
       前者交给foo这个Context来处理, 后者交给bar这个Context来处理。
       很明显吧! context的意思其实就是一个web app的意思。
       我们通常都会在server.xml里面做这样的配置
       <Context path="/foo" docBase="D:/project/foo/web" />
       这个context容器,就是用来干我们该干的事儿的地方的。

     

    毕竟TOMCAT的框架还是比较复杂的, 单是从文字上理解, 是不那么容易掌握TOMCAT的框架的。 所以得实践、实践、再实践。 建议下载一份TOMCAT的源码, 调试通过, 然后单步跟踪其启动过程。 如果有不明白的地方, 再来查阅本文, 看是否能得到帮助。 我相信这样效果以及学习速度都会好很多!
      
    1. Tomcat的整体框架结构
       Tomcat的基本框架, 分为4个层次。
       Top Level Elements:
        Server
        Service  
       Connector
        HTTP
        AJP
       Container
       Engine
         Host
       Context
       Component 
        manager
       logger
       loader
       pipeline
       valve
             ...
       站在框架的顶层的是Server和Service
       Server:  其实就是BackGroud程序, 在Tomcat里面的Server的用处是启动和监听服务端事件(诸如重启、关闭等命令。 在tomcat的标准配置文件:server.xml里面, 我们可以看到“<Server port="8005" shutdown="SHUTDOWN" debug="0">”这里的"SHUTDOWN"就是server在监听服务端事件的时候所使用的命令字)
       Service: 在tomcat里面, service是指一类问题的解决方案。  通常我们会默认使用tomcat提供的:Tomcat-Standalone 模式的service。 在这种方式下的service既给我们提供解析jsp和servlet的服务, 同时也提供给我们解析静态文本的服务。
      
       Connector: Tomcat都是在容器里面处理问题的, 而容器又到哪里去取得输入信息呢?
    Connector就是专干这个的。 他会把从socket传递过来的数据, 封装成Request, 传递给容器来处理。
       通常我们会用到两种Connector,一种叫http connectoer, 用来传递http需求的。 另一种叫AJP, 在我们整合apache与tomcat工作的时候, apache与tomcat之间就是通过这个协议来互动的。 (说到apache与tomcat的整合工作, 通常我们的目的是为了让apache 获取静态资源, 而让tomcat来解析动态的jsp或者servlet。)
       Container: 当http connector把需求传递给顶级的container: Engin的时候, 我们的视线就应该移动到Container这个层面来了。
       在Container这个层, 我们包含了3种容器: Engin, Host, Context.
       Engin: 收到service传递过来的需求, 处理后, 将结果返回给service( service 是通过 connector 这个媒介来和Engin互动的 ).
       Host: Engin收到service传递过来的需求后,不会自己处理, 而是交给合适的Host来处理。
    Host在这里就是虚拟主机的意思, 通常我们都只会使用一个主机,既“localhost”本地机来处理。
       Context: Host接到了从Host传过来的需求后, 也不会自己处理, 而是交给合适的Context来处理。
       比如: <http://127.0.0.1:8080/foo/index.jsp>
             <http://127.0.1:8080/bar/index.jsp>
       前者交给foo这个Context来处理, 后者交给bar这个Context来处理。
       很明显吧! context的意思其实就是一个web app的意思。
       我们通常都会在server.xml里面做这样的配置
       <Context path="/foo" docBase="D:/project/foo/web" />
       这个context容器,就是用来干我们该干的事儿的地方的。

    展开全文
  • 学习SpringMVC和tomcat,并把整个过程串联起来, 下面这张图是我把网上关于tomcat和springMVC的图串联起来, 并加上一些自己的理解。希望对大家有帮助。 ...

    学习SpringMVC和tomcat,并把整个过程串联起来, 下面这张图是我把网上关于tomcat和springMVC的图串联起来,

    并加上一些自己的理解。希望对大家有帮助。

    展开全文
  • Tomcat8源码分析系列-tomcat框架设计

    千次阅读 2018-01-13 14:51:06
    总体架构 tomcat的总体架构如下图所示(摘自...如上图所示,tomcat由Server、Service、Engine、Connerctor、Host、Context组件组成,其中带有s的代表在一个tomcat实例上可以存在多个组件,比如Context(s),tomcat...
  • 配置完ssm框架,想要运行检验,结果tomcat总是报错,显示 严重: 配置应用程序监听器[org.springframework.web.context.ContextLoaderListen 网上看了很多方法,都不太靠谱,最后整合了才弄出来。 1、打开File下面...
  • Tomcat基本架构解析(Tomcat架构解析学习笔记)

    万次阅读 多人点赞 2018-12-06 10:42:56
    1.Tomcat组件架构设计 1)server 服务器可以描述为这样一个应用:接收客户端发来的请求数据并进行解析,完成相关业务处理,然后把处理结果作为相应返回给客户端。 通常我们可以使用serversocket监听指定端口...
  • tomcat工作原理-框架

    2019-04-12 01:17:45
    NULL 博文链接:https://xylong.iteye.com/blog/1698814
  • 浅谈tomcat 服务器框架

    2018-05-04 16:59:35
    tomcat 是一种比较大众化的服务器,接触过开发的人都不陌生,在此不做详细复述,那么tomcat 是怎样工作的呢?首先看下图:从上图我们可以大致看出tomcat工作流程,1.首先客户端进行请求(可以是浏览器,也可以是其他...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 196,491
精华内容 78,596
关键字:

tomcat框架