0
0

【JavaWeb开发-Servlet】day02-使用eclipse实现Servlet开发

1、安装IDE-eclipse编译器

免安装版本：

优点：占用内存小

缺点：库少，需要自己导

链接：https://pan.baidu.com/s/1cAjseFiHe1A7BeAV_YWYMA
提取码：3zss

安装版（下载时务必选择Java Web Project）：

有点：环境比较完整，库全

缺点：占用内存较大

链接：https://pan.baidu.com/s/1j5L3KCuNv0KPSVHSSvwFcw
提取码：5koy

2、配置IDE开发环境

（1）使用eclipse关联Tomcat服务器

    点击菜单栏window->选择Preferences->在·搜索框中输入Server![](https://img-blog.csdnimg.cn/3d5a3be4964b4682accde565e2101cc1.png)

->选择Runtime Environments-> 点击Add按钮->

找到对应的服务器版本（下面的复选框先不用选）->点击Next

->填好服务器和JDK的环境路径->点击finish

状态栏显示服务后，点击OK，Tomcat服务器就添加进来了。

->点击菜单栏window->选择Show VIew->在other中找到server

->选择servers，点击OK

->下方的工具栏出现servers选项卡后，点击蓝色链接创建一个新服务对象。

->填好主机名称和服务名->点击下一步 ->再点下一步。

->双击下方新建的服务器名

->选择overview选项卡

->在server location里选择第二个选项，用自己下载的Tomcat服务器并添加好路径。->在DeployPath中的路径也改为本地下载的Tomcat中的webapps文件夹。->ctrl+s保存。

->右键点击服务器名，选择启动服务器

->访问浏览器http://127.0.0.1:8080/

如下页面，说明服务器启动成功。

（2）使用Servlet访问Hello World页面

    新建一个项目，项目类型：Dynamic Web Project

起个项目名字，点击下一步

再点下一步

勾选，生成xml部署描述文件，点击finish

可见如下初始项目结构

在src/main/java下新建一个firsttest包

在包中新建一个Servlet服务，没有的话就在下面other中搜索

起个类名

点击下一步，将暂时还用不到的勾选删掉

点击Finsh。

将代码进一步整理，留下想用的部分

package firsttest;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class testServlet extends HttpServlet {
    
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
    }

}

编写如下代码：

package firsttest;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class testServlet extends HttpServlet {
    
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                //设置响应消息头  告诉历览器 我给你的数据是一个用文本格式写的html文件
                response.setContentType("text/html");
                //获取tomcat服务器针对于浏览器的数据输出流
                PrintWriter out=response.getWriter();
                //通过输出流将<h1>Hello World</h1> 由服务器发送给浏览器
                out.println("<h1>Hello World</h1>");
                //关闭流
                out.close();
    }

}

保存后，打开web,xml文件，写如下内容：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>firsttest.testServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

保存，右键服务器，选择Add and Remove

将firsttest从左边添加到右边，点击finish

右键服务名点击运行

打开浏览器输入网址：http://127.0.0.1:8080/firsttest/hello

我们的第一个在IDE上运行的Servlet程序就大功告成了。

（3）Java中常用的方法调用方式

a,调用静态方法 可以通过类名直接调用
b,调用非静态方法 通过实例对象调用

创建两个类：

方法类A.class：

package firsttest;

public class A {
    public static void f1() {
        System.out.println("f1静态方法！");
    }
    
    public void f2() {
        System.out.println("f2非静态方法！");
    }
}

方法调用的测试类testA.class：

package firsttest;

public class testA {
    public static void main(String[] args) {
        //调用静态方法：直接调用
        A.f1();
        //调用非静态方法：先创建类对象
        A a = new A();
        a.f2();
    }
}

运行测试：

输出：

（4）Java中常用的反射机制示例

Java当中的反射机制：Java实现自我管理的一种机制。

反射语法：
要想实现反射必须获取一个 介质
获取当前类的类对象的方式又三种
Class cls=String.class
Class cls=Class.forName("java.lang.String")
Class cls="abc".getClass();
反射最主要的的意义可以实现代码的解耦

反射示例1：

新建一个反射示例类：

    通过反射函数将字符型参数的类对象的类名、属性和方法名打印输出。

package firsttest;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

public class RelectDemo {

    public static void  main(String[] args) {
        //静态方法直接调用:将String类型变量传给反射函数
        reflect("s");
    }
    
    public static void reflect(Object obj) {
        //通过一个实例类的getClass方法获取当前类的类对象(相当于获取了一个反射介质)
        Class cls = obj.getClass();
        //通过反射机制可以获取当前类的名字
        System.out.println("类:"+cls.getName());
        //获取属性
        Field[] fs=cls.getDeclaredFields();
        System.out.println("属性:");
        for(Field f:fs){
            System.out.println(f.getType()+" "+f.getName());
        }
        //获取方法
        Method[] ms=cls.getDeclaredMethods();
        System.out.println("方法 ");
        for(Method m:ms){
            System.out.print(m.getReturnType()+" ");
            System.out.print(m.getName()+" ");
            System.out.println(Arrays.toString(m.getParameterTypes()));
        }
        //获取构造方法
        Constructor[] cons=cls.getDeclaredConstructors();
        System.out.println("构造方法:");
        for(Constructor c:cons){
            System.out.print(c.getName()+"  ");
            System.out.println(Arrays.toString(c.getParameterTypes()));
        }
    }
}

输出：

反射示例2：

    通过反射机制对类解耦。

先来写一个强耦合的例子：

创建以下类：

face、eyes、bigEyes、smallEyes都是普通类，其中bigEyes、smallEyes继承eyes类。

face:

package firsttest;

public class face {
    public eyes e;
    public face() {
        this.e = new bigEyes();
    }
}

eyes:

package firsttest;

public class eyes {
    
}

smallEyes:

package firsttest;

public class smallEyes extends eyes{
    public String toString() {
        return "this is smallEyes";
    }
}

bigEyes:

package firsttest;

public class bigEyes extends eyes{
    public String toString() {
        return "this is bigEyes";
    }
}

测试类：

package firsttest;

public class test {

    public static void main(String[] args) {
        face face = new face();
        System.out.println(face.e);
    }

}

输出：

通过在主方法里创建face对象，调用的face函数时输出的eyes只能输出bigEyes。因为在face方法中已经写死了。

此时我们输出的眼睛对象只能输出“大眼睛”，虽然我们可以通过修改代码来控制输出的e的对象，但是不够灵活，耦合度太高了，不能很好的做到自我管理（管理子类对象），需要使用反射机制进行解耦。

反射解耦：

face.class:

package firsttest;

public class face {
    public eyes e;
    public face() throws Exception{
        try {
            //获取当前类的类对象
            Class cls=Class.forName("firsttest.smallEyes");
            //强制类型转换将类对象实例化
            this.e = (eyes)cls.newInstance();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
    }
}

test.class:

package firsttest;

public class test {

    public static void main(String[] args) throws Exception {
        face face = new face();
        System.out.println(face.e);
    }

}

其他类不变，输出：

这一步，通过反射机制，创建了一个smallEyes的反射介质（也就是smallEyes的类对象）通过实例化这个对象，完成输出smallEyes，把这个对象换成BigEyes，就会生成新的的反射对象，从而输出bigEyes。 但是这样还是体现不出反射的好处，下面使用IO流加强程序的改进：

创建一个a.txt文件

在a.txt中写一个类名

修改face类，使用IO流读取a,txt中的内容：

face.class

package firsttest;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class face {
    public eyes e;
    public face() throws Exception{
        try {
            FileInputStream in=new FileInputStream("src/main/java/firsttest/a.txt");
            InputStreamReader inr=new InputStreamReader(in);
            BufferedReader r=new BufferedReader(inr);
            //每次读取一行
            String str=r.readLine();
            Class cls=Class.forName(str);
            this.e = (eyes)cls.newInstance();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
    }
}

其他不动，进行测试：

如果将a.txt中的内容改为firsttest.smallEyes

测试输出：

可见，只要将想要反射的类写在a.txt文件中就可以实现不同类的调用了。充分体现了反射的优势，实现代码的解耦。

标签： eclipse servlet java
本文转载自: https://blog.csdn.net/qq_51701007/article/details/128204403
版权归原作者 代码骑士 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【JavaWeb开发-Servlet】day02-使用eclipse实现Servlet开发”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航