精华内容
下载资源
问答
  • jsp上传文件模块代码,测试成功的,同学录相片上传可直接应用
  • 该代码完全可以运行,配合我的博客进行,持续改良。
  • jsp+hibernate+oracle出库单模块,通过了juint测试
  • JSP多个模块时解决方法

    千次阅读 2016-08-16 09:56:54
    当一个页面有多个模块,最好的方式是:将每个模块抽离成一个单独的JSP。 界面简洁,易于查询问题所在。 (1)场景一 只有多个模块,不存在动态生成模块 JSP <%@page prefix="c" uri="http://java.sun.com/jsp/jstl/...

    当一个页面有多个模块,最好的方式是:将每个模块抽离成一个单独的JSP。 界面简洁,易于查询问题所在。

    (1)场景一
    只有多个模块,不存在动态生成模块

    JSP
    <%@page prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <c:import url="/admin/notice/noticeList"></c:import>
    
    
    Java
    
    @Controller
    @RequestMapping("/admin/notice")
    public class ActivityNoticeController {
        @RequestMapping(value="noticeList") {
            ...
    
            return "live/ActivityNotice"; //这里返回的是一个页面,前提是xml文件定义拦截格式
        }
    }

    场景二
    页面有多个模块,有动态生成部分

    例如:

    javascript
    <script type="javascript/text" src="../static/js/jquery.1.11.3.js">
    
    $(function() {
        $('.btn').click(function(){
            var str = '';
            for(var i=0; i<5; i++) {
                str += '<option id='+i+'>'+(index+i)+'</option>';
            }
            $('.ul').html(str);
        })
    })

    若有动态生成的html表单元素需要有选中事件:

    两种解决方案:
    (1)界面中html代码部分触发事件的方式,都使用function的方式
    (2)在抽离的模块html部分,重新对事件进行添加

    (1)绑定function方式

    例如:

    JSP
    
    <table>
        <tr>
            <th>姓名</th>
            <th>信息</th>
            <th>操作</th>
        </tr>
        <tr>
            <td>测试</td>
            <td>test</td>
            <td>
                <button class="edit" onclick="javascript:edit(this)">编辑</button>
                <button class="view" onclick="javascript:view(this)">查看</button>
                <button class="del" onclick="javascript:delete(${course.id})">删除</button>
            </td>
        <tr>
    </table>
    
    Javascript
    
    function edit(){
        ...
    }
    
    ...

    这样的方式,无论动态html代码如何生成。在生成的html中,总绑定了对事件的调用。可以保证动态元素生成时,不会造成元素绑定的丢失

    (2)在模块页面重新对元素进行绑定

    例如:

    JSP
    
    <table>
        <tr>
            <th>姓名</th>
            <th>信息</th>
            <th>操作</th>
        </tr>
        <tr>
            <td>测试</td>
            <td>test</td>
            <td>
                <button class="edit">编辑</button>
                <button class="view">查看</button>
                <button class="del">删除</button>
            </td>
        <tr>
    </table>
    
    Javascript
    $(function(){
    
        1.使用jquery中的on元素进行动态绑定
        $('.edit').on('click',function(){
            ...
        })
    
        2.关闭元素绑定,并进行新的绑定
        $('.view').off('click').click(function(){
            ...
        })
    
        //两种都可
    })

    这样的方式也能够保证动态生成Html代码部分可以绑定元素事件。

    相比较而言:第一种方式更加优雅

    场景三
    页面有多个模块、每个模块动态生成、每个模块中有元素绑定增删改查、分页等功能

    其他需要解决的是:
    (1)增删改查不能够刷新页面,以免造成菜单栏跳回课程安排
    页面菜单栏
    (2)分页不能乱(当前第几页刷新后还是第几页)

    解决方案:

    1.增删改都使用异步操作

        @ResponseBody
        @RequestMapping(value="save")
        public String save(Entity entity) {
            JsonObject obj = new JsonObject();
            ...
            Entity e = service.save(entity);
            obj.put("entity", e);
            ...
            return obj.toString();
        }
    
        ...

    2.进行完异步操作之后,重新对模块页面进行动态刷新。

    page记录当前是第几页。通过查询返回异步操作后,第几页的记录。

    function search(page) {
        $.post('/admin/notice/noticeList', {'page':page},function(d){
            $('.div').html(d); //返回的是页面拼装的html代码
        })
    }
    展开全文
  • 书名:JSP网站开发典型模块与实例精讲 图书编号:1656674 出版社:电子工业 定价:50.0 ISBN:712102874 作者:李振捷 出版日期:2006-08-09 版次: 开本:26cm 简介: 本书讲解了使用JSP开发网站系统的经典模块和工程实例。...
  • 详细设计主要包括系统数据库访问的实现,主要功能模块的具体实现,模块实现关键代码等。最后对系统进行功能测试,并对测试结果进行分析总结。 包括程序毕设程序源代码一份,数据库一份,完美运行。配置环境里面有...
  • 模块化架构之tomcat的jsp加载处理

    千次阅读 2015-11-09 15:06:39
    jsp模块化加载

    最近一直在思考模块化项目的架构问题,也学过一点点OSGI的东西,感觉有点高大上,自身目前还用不上,或者用的不够好。就想着能不能实现一个简单一点的模块化方式,于是便有了前一篇的阅读spring源码,解决了实体实例化上的模块化问题,下面我们来看看资源模块化的问题,主要是jsp。我们都知道,对于服务器(tomcat)来说,要求jsp都要在项目目录下,那如果我们要把jsp封装到相对应的模块jar包中呢,tomcat还能加载吗?

    一开始,笔者只是简单的做了读取操作,对于jsp的请求都拦截了读取内容返回前台,结果就出现了很喜感的一幕,jsp根本就不能好好执行,这时笔者才想起来,jsp本质上是一个变种servlet,而不是一个单纯的html页面。于是我们又开始了阅读源码的过程。

    通过阅读我们发现,tomcat处理jsp的关键是其默认配置了一个JSPServlet类,用于处理所有的jsp文件。通过分析Service方法和serviceJspFile方法我们发现了tomcat对于jsp的处理基本过程是:

    首先,通过uri获取要处理的jsp路径。

    其次,尝试从JspRuntimeContext缓存容器中获取JspWrapper如果没有,就开启线程同步去构建一个,构建时会通过context.getResource来判断是否有jsp文件(也就是该方法限定了jsp必须在项目目录下,也就是配置的docBase目录下)。

    第三,如果有,就创建JSPWrapper并以uri为key加入缓存中。

    第四,调用JspWrapper.service方法来完成jsp响应(该方法完成了jsp的编译存储和服务处理。每次都会判断是不是开发模式和最后一次修改时间,如果有更新就重新编译)

    在阅读中我们发现,对于jsp资源获取的关键类实际上只有3个一个是JSPServlet,一个是JspWrapper一个是JspCompilationContext.这三个类。

    JSPServlet说了,是用于处理*.jsp的请求,负责获取jsp的路径,并查找相关的JSPWrapper来响应。

    JSPWrapper,包装了jsp文件,完成了jsp的编译,和响应

    JspCompilationContext,Jsp的编辑容器,完成了jsp的资源查找和编辑器创建等操作,在jsp第一次加载的时候完成了大量的初始化工作。


    下面我们就改造这三个类来实现我们自己的想法,这里我继承这三个类分别作了ModuleJspServlet,ModuleJSPWrapper和ModuleJSPCompilationContext类,来完成相关的扩展功能。

    ModuleJspServlet中我们简单修改了,判断方法,也就是不在简单的使用ServletContext.getResource来判断是否存在jsp,而是通过JspCompilationContext来判断。


     private void serviceJspFile(HttpServletRequest request,
                                    HttpServletResponse response, String jspUri,
                                    Throwable exception, boolean precompile)
            throws ServletException, IOException {
    
            JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
           <span style="color:#ff0000;"> ModuleJspCompilationContext jc = new ModuleJspCompilationContext(jspUri, false, options, context, null, rctxt);</span>
            if (wrapper == null) {
                synchronized(this) {
                    wrapper = rctxt.getWrapper(jspUri);
                    if (wrapper == null) {
                        // Check if the requested JSP page exists, to avoid
                        // creating unnecessary directories and files.
                        if (<span style="color:#ff0000;">null == jc.getResource(jspUri)</span>) {
                            handleMissingResource(request, response, jspUri);
                            return;
                        }
                        boolean isErrorPage = exception != null;
                        wrapper = new ModuleJspServletWrapper(config, options, jspUri,
                                                        isErrorPage, rctxt);
                        rctxt.addWrapper(jspUri,wrapper);
                    }
                }
            }
    
            try {
                wrapper.service(request, response, precompile);
            } catch (FileNotFoundException fnfe) {
                handleMissingResource(request, response, jspUri);
            }
    
        }
    红色部分使我们的修改。这个类的修改比较简单。

    对于ModuleJSPWrapper我们也只是修改了其构造函数:

    public ModuleJspServletWrapper(ServletConfig config, Options options,
    			String jspUri, boolean isErrorPage, JspRuntimeContext rctxt)
    			throws JasperException {
    		super(config, options, jspUri, isErrorPage, rctxt);
    		this.isTagFile = false;
    		this.config = config;
    		this.options = options;
    		<span style="color:#ff0000;">if(jspUri.startsWith("jar:file:")) {
    			jarPath = jspUri.substring(0,jspUri.indexOf("!/") + 2);
    			jspUri = jspUri.substring(jspUri.indexOf("!/") + 1);
    		}else if(jspUri.startsWith("file:")) {//文件系统开始,以此开头处理的是开发模式下
    			jarPath = jspUri.substring(0,jspUri.indexOf("/") + 1);
    			jspUri = jspUri.substring(jspUri.indexOf("/"));
    		}</span>
    		this.jspUri = jspUri;
    		ctxt = new ModuleJspCompilationContext(jspUri, isErrorPage, options,
    				config.getServletContext(), this, rctxt);
    	}
    这里增加了对于jar包文件和工作空间的处理,后者是针对开发的便利性提出的开发模式来的,这样在完成开发前都可以不用打包。

    主要的修改在ModulJspCompilationContext中,获取资源的方法我们做了下简单修改。

     public URL getResource(String res) throws MalformedURLException {
            URL result = null;
            if (res.startsWith("/META-INF/")) {
                // This is a tag file packaged in a jar that is being compiled
                URL jarUrl = tagFileJarUrls.get(res);
                if (jarUrl == null) {
                    jarUrl = tagFileJarUrl;
                }
                if (jarUrl != null) {
                    result = new URL(jarUrl.toExternalForm() + res.substring(1));
                }
            } else if (res.startsWith("jar:file:") || res.startsWith("file:")) {
                    // This is a tag file packaged in a jar that is being checked
                    // for a dependency
                    result = new URL(res);
    
           <span style="color:#ff0000;"> } else if (this.jarPath != null){
            	result = new URL(jarPath + res);</span>
            }else {
                result = context.getResource(canonicalURI(res));
            }
            return result;
        }
    


    我们针对自己的路径做了下处理。这样就完成了jsp的跨项目加载和模块化加载。


    总结:这里通过跟踪分析,知识修改了jsp的加载方式,不在只是从项目目录下加载。其他未做修改。

    在测试时发现,我们单纯的返回资源不设置请求响应码,容易造成浏览器莫名其妙的缓存问题。这点算是额外收获了。





    展开全文
  • * 多模块jsp访问,默认是src/main/webapp,但是多模块的目录只设置yml文件不行 * @return */ @Bean public InternalResourceViewResolver viewResolver () { InternalResourceViewResolver resolver...

    一、参数验证

    • 实体类,一下表示最小18,大于18会报错
    @Min(value = 18, message = "默认message信息")
    private Integer age;
    • 业务层,@Validated表示要验证,bindingResult验证的信息
    @PostMapping(value = "/mans")
    public Object manAdd(@Validated Man man, BindingResult bindingResult){
        if(bindingResult.hasErrors()){
            return bindingResult.getFieldError().getDefaultMessage(); // 返回默认message
        }
        return manRepository.save(man);
    }

    二、AOP

    • 加入依赖
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    • 简单的测试before,先写完方法注解就可以提示了。
    @Aspect     // 切面
    @Component      // 加入spring的依赖
    public class HttpAspect {
        // spring内置是使用logback,引入的是 import org.slf4j.Logger; 这个log的jar包
        private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);
    
        //如果拦截所有该类中的方法public * com.imooc.ManController.*(..)
        //如果拦截所有类 * public * com.imooc.*.*(..),但是多类有requestMapping的话会算两次
    
        @Pointcut("execution(public * com.imooc.ManController.*(..))")
        public void log(){
        }
    
        @Before("log()")
        public void doBefore(JoinPoint joinpoint) {
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            // url
            logger.info("url={}", request.getRequestURL());
            // method
            logger.info("method={}", request.getMethod());
            // ip
            logger.info("ip={}", request.getRemoteAddr());
            // 类方法
            logger.info("class_method={}", joinpoint.getSignature().getDeclaringTypeName() + "." + joinpoint.getSignature().getName());
            // 参数
            logger.info("args={}", joinpoint.getArgs());
        }
    
        @After("log()")
        public void doAfter(){
            logger.info("22222222222");
        }
    
        /**
         * 返回信息展示,注意实体类需要一个toString方法
         * @param object
         */
        @AfterReturning(returning = "object", pointcut = "log()")
        public void doAfterReturning(Object object){
            logger.info("respone={}", object);
        }
    }
    

    三、统一异常处理

    • 自定义异常
    public class GirlException extends RuntimeException {
        private Integer code;
    
        public GirlException(Integer code, String msg) { //
            super(msg);
            this.code = code;
        }
    
        public GirlException(ResultEnum resultEnum){
            super(resultEnum.getMsg());
            this.code = resultEnum.getCode();
        }
    
        public Integer getCode() {
            return code;
        }
    }
    • spring的异常处理类
    @ControllerAdvice
    public class ExceptionHandle {
        private static final Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);
    
        @ExceptionHandler(value = Exception.class)
        @ResponseBody
        public Result handler(Exception e){
            if(e instanceof GirlException){
                GirlException girlException = (GirlException)e;
                return ResultUtil.error(girlException.getCode(), girlException.getMessage());
            } else {
                logger.error("【系统错误】", e);
                return ResultUtil.error(-1, "系统异常");
            }
        }
    }
    • 封装异常通知菜单类
    public enum ResultEnum {
        UNKONW_ERROR(-1, "未知错误"),
        SUCCESS(0, "成功"),
        ;
        private Integer code;
        private String msg;
    
        ResultEnum(Integer code, String msg) {
            this.code = code;
            this.msg = msg;
        }
    
        public Integer getCode() {
            return code;
        }
    
        public String getMsg() {
            return msg;
        }
    }
    • 封装异常对象
    public class Result<T> {
    
        private Integer code;
    
        private String msg;
    
        private T data;
    
        get/set方法
    }
    • 异常工具类
    public class ResultUtil {
        public static Result success(Object object){
            Result result = new Result();
            result.setCode(0);
            result.setMsg("成功");
            result.setData(object);
            return result;
        }
    
        public static Result success(){
            Result result = new Result();
            result.setCode(0);
            result.setMsg("成功");
            result.setData(null);
            return result;
        }
    
        public static Result error(Integer code, String msg){
            Result result = new Result();
            result.setCode(code);
            result.setMsg(msg);
            result.setData(null);
            return result;
        }
    }
    • 使用
      • return ResultUtil.error(1, “错误msg”);
      • throw new GirlException(ResultEnum.UNKONW_ERROR);

    四、单元测试

    • 使用idea自带的:在类里面右键鼠标选择 Go To -> Test 可以快速创建空的junit的测试类
    • 使用junit插件:类内使用alt+ins快速创建junit,不过格式是springmvc的
    • 代码:
    @RunWith(SpringRunner.class)
    @SpringBootTest
    @AutoConfigureMockMvc // api测试需要这个
    public class ManControllerTest {
    
        /**service测试*/
        @Autowired
        ManRepository manRepository;
        @Test
        public void testFindById() throws Exception { 
            Man man = manRepository.findOne(7);
            Assert.assertEquals(new Integer(100), man.getAge());
        }
    
        /**api测试*/
        @Autowired
        MockMvc mockMvc;
        @Test
        public void testManList() throws Exception {
            mockMvc.perform(MockMvcRequestBuilders.get("/mans"))  // get post put delete
                    .andExpect(MockMvcResultMatchers.status().isOk()) // isOK 是 200
                    .andExpect(MockMvcResultMatchers.content().string("")); // 判断内容
            // 判断的条件有很多
        }
    }
    • mvn clean package 就会自动测试了
    • 跳过测试:mvn clean package -Dmaven.test.skip=true

    五、整合jsp

    • 网上找了demo测试了以后jsp可以访问了,这里也记录一下
    • 默认目录是 src/main/webapp
    • 加配置:
    spring:
      mvc:
        view:
          prefix: /WEB-INF/jsp/
          suffix: .jsp
    • 目录结构
    • 代码
    @RequestMapping("/login")
       public String login(){
           return "login";
       }
    • 依赖
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
        <!--<scope>provided</scope>-->
    </dependency>

    五、多module下整合jsp

    • 将项目改为多模块以后竟然访问不了了,实验了几次以后成功,自定义类继承WebMvcConfigurerAdapter即可
    @EnableWebMvc
    @Configuration
    public class WebConfig extends WebMvcConfigurerAdapter {
    
        /** 指定默认文件的地址,jsp页面引入js和css的时候就不用管项目路径了 */
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            registry.addResourceHandler("/static/**")
                    .addResourceLocations(ResourceUtils.CLASSPATH_URL_PREFIX+"/static/");
            super.addResourceHandlers(registry);
        }
    
        /**
         * 多模块的jsp访问,默认是src/main/webapp,但是多模块的目录只设置yml文件不行
         * @return
         */
        @Bean
        public InternalResourceViewResolver viewResolver() {
            InternalResourceViewResolver resolver = new InternalResourceViewResolver();
            resolver.setViewClass(org.springframework.web.servlet.view.JstlView.class);
            resolver.setPrefix("/WEB-INF/jsp/"); // jsp目录
            resolver.setSuffix(".jsp");
            return resolver;
        }
    }
    
    • 打包以后jsp没有包含在jar里面,需要在pom.xml文件增加资源目录
    <build>
          <resources>
              <!-- 打包时将jsp文件拷贝到META-INF目录下-->
              <resource>
                  <!-- 指定resources插件处理哪个目录下的资源文件 -->
                  <directory>src/main/webapp</directory>
                  <!--注意此次必须要放在此目录下才能被访问到-->
                  <targetPath>META-INF/resources</targetPath>
                  <includes>
                      <include>**/**</include>
                  </includes>
              </resource>
              <resource>
                  <directory>src/main/resources</directory>
                  <includes>
                      <include>**/**</include>
                  </includes>
                  <filtering>false</filtering>
              </resource>
          </resources>
      </build>
    展开全文
  • Springboot集成jsp主要有以下几个步骤: 1、在pom.xml中添加依赖 2、新建web路径 3、配置application.properties支持jps Springboot集成JSP步骤详细: 1、引入依赖: 主要引入以下几个依赖项: &lt;!--...

    概述:

    Springboot集成jsp主要有以下几个步骤:

    1、在pom.xml中添加依赖

    2、新建web路径

    3、配置application.properties支持jps

    Springboot集成JSP步骤详细:

    1、引入依赖:

    主要引入以下几个依赖项:

    <!--jsp支持-->
    <!-- servlet 依赖. -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
    </dependency>
    <!-- tomcat 的支持.-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>

    2、新建webapp/WEB-INF目录:

    在src/main下新建目录 webapp/WEB-INF/jsp,目录结构如下图:

    3、配置application.properties:

    # 页面默认前缀目录
    spring.mvc.view.prefix=/WEB-INF/jsp/
    # 响应页面默认后缀
    spring.mvc.view.suffix=.jsp
    

    4、编写测试Controller:

    @Controller
    public class StudentController {
        @RequestMapping("ee")
        public String tt(Map<String, Object> map){
            map.put("name", "SpringBoot");
            map.put("date", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return "stu";
        }
    
        @RequestMapping("jtest")
        public String mm(Model mode){
            mode.addAttribute("name", "This is a Test");
            mode.addAttribute("date", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            return "stu";
        }
    }

    注意:使用@Controller注解 而不是@RestController,另外 以上两个接口都可以使用

     

    理论上按上面步骤,一个简单的web工程就可以使用jsp了,但是如果项目工程是使用多模块方式,则需要另外的配置。

     

    多模块项目中使用JSP:

    比如有下面一个多模块工程,需要在其中一个模块中使用jsp:

    解决方法1:

    在edit configuration中配置模块的工作路径,具体如下:

     

    解决方法2:

    @Configuration
    public class GlobalConfig {
        @Bean
        public WebServerFactoryCustomizer<TomcatServletWebServerFactory> customizer() {
            return (factory) -> {
                factory.addContextCustomizers((context) -> {
                            //模块中webapp相对路径
                            String relativePath = "tt-web/src/main/webapp";
                            File docBaseFile = new File(relativePath);
                            // 路径是否存在
                            if (docBaseFile.exists()) {
                                context.setDocBase(docBaseFile.getAbsolutePath());
                            }
                        }
                );
            };
        }
    }

     

    展开全文
  • 自定义权限模块1——SpringBoot支持JSP

    千次阅读 2017-08-12 14:36:13
    虽然springBoot官方建议大家使用thymeleaf,但是作为一名习惯了jsp的人来说,thymeleaf真的不怎么好用,还好springBoot还是支持jsp的,在这里教一下大家怎么配置。目录结构 首先在main目录下创建webapp/WEB-INF/jsp...
  • 经过一段时间的学习,实现了第一个JSP程序、简单的Servlet程序以及JSP+Javabean的简单Web计算器。这里作为一个综合性的练习,利用经典的MVC设计理念,实现一个用户注册模块的设计。在这里,JavaBean由于具有良好的...
  • 如:模块登录、文件上传下载、邮件收发模块、网上聊天室、留言模块、数据表格分页显示、BBS论坛模块,可以拿来即插即用!绝对方便,是开发测试的必备工具!!如有问题,可发邮件到:jiang165@163.com询问!鄙人会...
  • /WEB-INF/jsp/index.jsp controller代码: @GetMapping(value = "/index") public String index(){ System.out.println("------index--------"); return "index"; } application 配置了 spring.mvc....
  • 这个例子中没有用session,仅是简单的JDBC测试程序 使用session的版本更好:详见http://blog.csdn.net/ruantao1989/article/details/8045879  login_index.jsp 负责输入表格,然后提交到连接数据库检查...
  • 对于 IDE 而言,从它的方面去理解的话,其实还存在一个隐含的内建环境:就是我们开发时候,敲代码、测试、改 bug 的 IDE 环境,是我们开发者主要花时间的环境,这时 IDE 可以检查依赖的包是否导入了,能否提供代码...
  • 我对nginx_ajp_module模块测试心得

    千次阅读 2011-04-16 14:39:00
    测试了一下nginx ajp模块,发现可能有如下问题(有些问题并不是这个模块带来的):1、潜在bug,ngx_http_ajp.c:359行%s输出格式,但r->method不是字符串类型,而是ngx_uint_t类型,所以有可能会导致进程崩溃的情况...
  • JSP

    千次阅读 2009-11-16 18:11:00
    JSP目录[隐藏]JSP简介 JSP 2.0介绍 JSP技术的强势 JSP技术的弱势 JSP内置对象: JSP的技术方法 JSP的应用模型 JSP开发入门 jsp运行时经常遇到的问题及解决方法 JSP简介JSP 2.0介绍JSP技术的强势JSP技术的弱势JSP内置...
  • logIn.jsp 负责输入表格,然后提交到连接数据库检查的页面 logOut.jsp 负责注销(登出)操作 checkLogIn.jsp 负责连接JDBC, 检查login_index.jsp提交来的值,是否在数据库中 welcome.jsp 负责输出成功登录或...
  • Jsp jsp实现原理

    千次阅读 2018-03-30 19:45:24
    01_JSP的概述&amp;入门案例 JSP概述 全称是Java Server Pages,他和Servlet一样,也是Java所提供的一门用于开发动态WEB资源的技术, JSP也是JavaEE的规范之一,JSP的底层其实就是Servlet。 JSP的特点 编写JSP...
  • 使用环境:MyEclipse/Eclipse + Tomcat + MySQL。 使用技术:Spring MVC + Spring + MyBatis 或 JSP + Servlet + JavaBean + JDBC。
  • SpringBoot【整合JSP

    万次阅读 2019-05-12 21:56:48
      SpringBoot中默认是不支持jsp的,但是我们某些情况下可以又需要用到,所以本文记录下SpringBoot整合jsp的过程 整合JSP页面 1.创建控制器   创建一个自定义的控制器,处理请求,并跳转到jsp页面 /** * @...
  • jsp在线考试系统

    2015-04-24 15:27:41
    学生在线考试模块包括自由测试、单元测试、模拟测试、考试成绩和错题本这些功能模块。目前已经完成了原型,基本程序在Windows 2000和Linux 7.2中,使用Tomcat 5.5和JDK1.6和Mysql5.0进行了缜密的测试,目前可以良好...
  • JSP在线考试系统2.1.0

    2018-03-06 14:36:14
    这是一个JSP在线考试系统,后台数据库为MySQL。这是一个完整的web应用程序,实现了教师出题、学生在线考试(自由测试、单元测试... 学生在线考试模块包括自由测试、单元测试、模拟测试、考试成绩和错题本这些功能模块

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,795
精华内容 25,118
关键字:

jsp模块测试