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

代码骑士

已于 2022-12-10 19:30:33 修改

阅读量4.2k

点赞数 13

分类专栏： # 《代码骑士网站开发日记》文章标签： eclipse servlet java

于 2022-12-07 00:42:37 首次发布

本文链接：https://blog.csdn.net/qq_51701007/article/details/128204403

版权

《代码骑士网站开发日记》专栏收录该内容

102 篇文章 12 订阅

订阅专栏

1、安装IDE-eclipse编译器

2、配置IDE开发环境

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

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

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

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

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

->选择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文件中就可以实现不同类的调用了。充分体现了反射的优势，实现代码的解耦。

代码骑士

关注

13
点赞
踩
86

收藏

觉得还不错? 一键收藏
打赏
1
评论
【JavaWeb开发-Servlet】day02-使用eclipse实现Servlet开发

免安装版本：安装版（下载时务必选择Java Web Project）：点击菜单栏window->选择Preferences->在·搜索框中输入Server->选择Runtime Environments-> 点击Add按钮-> 找到对应的服务器版本（下面的复选框先不用选）->点击Next ->填好服务器和JDK的环境路径->点击finish 状态栏显示服务后，点击OK，Tomcat服务器就添加进来了。 ->点击菜单栏window->选择Show VIew->在other中找到server
复制链接

扫一扫