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

    目录

    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。

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

    1. package firsttest;
    2.  
    3. import java.io.IOException;
    4. import javax.servlet.ServletException;
    5. import javax.servlet.annotation.WebServlet;
    6. import javax.servlet.http.HttpServlet;
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9.  
    10. public class testServlet extends HttpServlet {
    11. 	
    12. 	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    13. 		
    14. 	}
    15.  
    16. }

    编写如下代码：

    1. package firsttest;
    2.  
    3. import java.io.IOException;
    4. import java.io.PrintWriter;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11.  
    12. public class testServlet extends HttpServlet {
    13. 	
    14. 	protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15. 				//设置响应消息头  告诉历览器 我给你的数据是一个用文本格式写的html文件
    16. 				response.setContentType("text/html");
    17. 				//获取tomcat服务器针对于浏览器的数据输出流
    18. 				PrintWriter out=response.getWriter();
    19. 				//通过输出流将
      Hello World
       由服务器发送给浏览器
    20. 				out.println("
      Hello World
      "      );
    21. 				//关闭流
    22. 				out.close();
    23. 	}
    24.  
    25. }

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

    1. "1.0" encoding="UTF-8"?>
    2. <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">
    3. 	<servlet>
    4. 		<servlet-name>helloservlet-name>
    5. 		<servlet-class>firsttest.testServletservlet-class>
    6. 	servlet>
    7. 	<servlet-mapping>
    8. 		<servlet-name>helloservlet-name>
    9. 		<url-pattern>/hellourl-pattern>
    10. 	servlet-mapping>
    11. web-app>

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

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

     右键服务名点击运行

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

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

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

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

    创建两个类：

     方法类A.class：

    1. package firsttest;
    2.  
    3. public class A {
    4. 	public static void f1() {
    5. 		System.out.println("f1静态方法！");
    6. 	}
    7. 	
    8. 	public void f2() {
    9. 		System.out.println("f2非静态方法！");
    10. 	}
    11. }

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

    1. package firsttest;
    2.  
    3. public class testA {
    4. 	public static void main(String[] args) {
    5. 		//调用静态方法：直接调用
    6. 		A.f1();
    7. 		//调用非静态方法：先创建类对象
    8. 		A a = new A();
    9. 		a.f2();
    10. 	}
    11. }

     运行测试：

     输出：

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

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

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

    反射示例1：

    新建一个反射示例类：

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

    1. package firsttest;
    2.  
    3. import java.lang.reflect.Constructor;
    4. import java.lang.reflect.Field;
    5. import java.lang.reflect.Method;
    6. import java.util.Arrays;
    7.  
    8. public class RelectDemo {
    9.  
    10. 	public static void  main(String[] args) {
    11. 		//静态方法直接调用:将String类型变量传给反射函数
    12. 		reflect("s");
    13. 	}
    14. 	
    15. 	public static void reflect(Object obj) {
    16. 		//通过一个实例类的getClass方法获取当前类的类对象(相当于获取了一个反射介质)
    17. 		Class cls = obj.getClass();
    18. 		//通过反射机制可以获取当前类的名字
    19. 		System.out.println("类:"+cls.getName());
    20. 		//获取属性
    21. 		Field[] fs=cls.getDeclaredFields();
    22. 		System.out.println("属性:");
    23. 		for(Field f:fs){
    24. 			System.out.println(f.getType()+" "+f.getName());
    25. 		}
    26. 		//获取方法
    27. 		Method[] ms=cls.getDeclaredMethods();
    28. 		System.out.println("方法 ");
    29. 		for(Method m:ms){
    30. 			System.out.print(m.getReturnType()+" ");
    31. 			System.out.print(m.getName()+" ");
    32. 			System.out.println(Arrays.toString(m.getParameterTypes()));
    33. 		}
    34. 		//获取构造方法
    35. 		Constructor[] cons=cls.getDeclaredConstructors();
    36. 		System.out.println("构造方法:");
    37. 		for(Constructor c:cons){
    38. 			System.out.print(c.getName()+"  ");
    39. 			System.out.println(Arrays.toString(c.getParameterTypes()));
    40. 		}
    41. 	}
    42. }

    输出： 

     反射示例2：

            通过反射机制对类解耦。

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

    创建以下类：

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

    face:

    1. package firsttest;
    2.  
    3. public class face {
    4. 	public eyes e;
    5. 	public face() {
    6. 		this.e = new bigEyes();
    7. 	}
    8. }

    eyes:

    1. package firsttest;
    2.  
    3. public class eyes {
    4. 	
    5. }

    smallEyes:

    1. package firsttest;
    2.  
    3. public class smallEyes extends eyes{
    4. 	public String toString() {
    5. 		return "this is smallEyes";
    6. 	}
    7. }

    bigEyes:

    1. package firsttest;
    2.  
    3. public class bigEyes extends eyes{
    4. 	public String toString() {
    5. 		return "this is bigEyes";
    6. 	}
    7. }

    测试类：

    1. package firsttest;
    2.  
    3. public class test {
    4.  
    5. 	public static void main(String[] args) {
    6. 		face face = new face();
    7. 		System.out.println(face.e);
    8. 	}
    9.  
    10. }

    输出：

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

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

    反射解耦：

    face.class:

    1. package firsttest;
    2.  
    3. public class face {
    4. 	public eyes e;
    5. 	public face() throws Exception{
    6. 		try {
    7. 			//获取当前类的类对象
    8. 			Class cls=Class.forName("firsttest.smallEyes");
    9. 			//强制类型转换将类对象实例化
    10. 			this.e = (eyes)cls.newInstance();
    11. 		} catch (ClassNotFoundException e1) {
    12. 			e1.printStackTrace();
    13. 		}
    14. 	}
    15. }

    test.class:

    1. package firsttest;
    2.  
    3. public class test {
    4.  
    5. 	public static void main(String[] args) throws Exception {
    6. 		face face = new face();
    7. 		System.out.println(face.e);
    8. 	}
    9.  
    10. }

    其他类不变，输出：

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

    创建一个a.txt文件

     在a.txt中写一个类名

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

    face.class

    1. package firsttest;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.FileInputStream;
    5. import java.io.InputStreamReader;
    6.  
    7. public class face {
    8. 	public eyes e;
    9. 	public face() throws Exception{
    10. 		try {
    11. 			FileInputStream in=new FileInputStream("src/main/java/firsttest/a.txt");
    12. 			InputStreamReader inr=new InputStreamReader(in);
    13. 			BufferedReader r=new BufferedReader(inr);
    14. 			//每次读取一行
    15. 			String str=r.readLine();
    16. 			Class cls=Class.forName(str);
    17. 			this.e = (eyes)cls.newInstance();
    18. 		} catch (ClassNotFoundException e1) {
    19. 			e1.printStackTrace();
    20. 		}
    21. 	}
    22. }

    其他不动，进行测试：

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

    测试输出：

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

  • 相关阅读:
    JS判断数据类型
    Spring boot多数据源实现动态切换
    【JavaSE】static关键词
    阿里云服务器公网带宽如何修改？
    Ubuntu：解决PyCharm中不能输入中文或者输入一个中文解决方法
    java中常量池
    用于NLP领域的排序模型最佳实践
    vue 调试工具devtools
    Tomcat多实例和负载均衡动静分离
    Softmax回归——动手学深度学习笔记
  • 原文地址：https://blog.csdn.net/qq_51701007/article/details/128204403