上下没中

JavaWeb—监听器—Eclipse版动力节点学习笔记

JavaWeb学习笔记

监听器 Listener

哔哩哔哩蛙课网【动力节点】JavaWeb-Eclipse版学习视频网址

	解释	归属	备注
ServletRequestListener	Request 创建及销毁的监听	Servlet
ServletRequestAttributeListener	request 域属性的添加、修改、删除的监听	Servlet
HttpSessionListener	Session 对象的创建及销毁的监听	Servlet
HttpSessionAttributeListener	Session 域属性的添加、修改、删除的监听	Servlet
ServletContextListener	ServletContext 对象的创建及销毁的监听	Servlet
ServletContextAttributeListener	ServletContext 域属性的添加、修改、删除的监听	Servlet
HttpSessionBindingListener	监听指定类型对象与 Session 的绑定与解绑	Servlet	不需要注册
HttpSessionActivationListener	监听在 Session 中存放的指定类型对象的钝化与活化	Servlet	钝化：出内存入硬盘，活化：出硬盘入内存
Serializable	监控钝化与活化同时要实现的接口	Servlet
.getRemoteAddr()	获得远程地址IP	Servlet

1、监听器相关设计模式

在 Servlet 规范中存在三大组件：Servlet 接口、Listener 接口、Filter 接口。我们在这里要学习监听器接口 Listener。监听器是一种设计模式，是观察者设计模式的一种实现。所以我们需要先学习观察者设计模式，再学习监听器设计模式。

1.1、设计模式

设计模式是指，可以重复利用的解决方案。由 GoF（Gang of Four，四人组）于 1995年提出。他们提出了三类 23 种设计模式。这三类分别为：

1.1.1、创建型

通过特定方式创建特定对象的设计模式。例如，工厂方法模式、单例模式等。

1.1.2、结构性

为了解决某一特定问题所搭建的特定代码结构的设计模式。例如，适配器模式（实现接口的一部分方法）、代理模式等。

1.1.3 、行为型

通过构建不同的角色来完成某一特定功能的设计模式。例如，模板方法模式、观察者模式等。

1.2、观察者设计模式

从现实角度来说，我们每一个人都是一个观察者，同时也是一个被观察者。

作为被观察者，我们会发出一些信息，观察者在接收到这些信息后，会做出相应的反映；
而作为观察者，我们是可以被“被观察者”所发出的信息影响的。
一个被观察者，可能存在多个观察者。也就是说，一个被观察者所发出的信息，可能会影响到多个观察者。

观察者设计模式，定义了一种一对多的关联关系。一个对象 A 与多个对象 B、C、D 之间建立“被观察与观察关系”。当对象 A 的状态发生改变时，通知所有观察者对象 B、C、D。当观察者对象 B、C、D 在接收到 A 的通知后，根据自身实际情况，做出相应改变。

当然，观察者与被观察者指的都是具有某一类功能的对象，所以这里的观察者与被观察者都是指的接口，而真正的观察者对象与被观察者对象，是指实现了这些接口的类的对象。

1.2.1 定义观察者接口

1.2.2 定义被观察者接口

1.2.3 定义观察者

这里定义了两个观察者：1 号与 2 号观察者。

1.2.4、定义被观察者

被观察者类除了要实现观察者接口 IObservable 外，还需要在类中声明并创建一个观察者集合，用于向其中添加观察者。

1.2.5、定义测试类

1.2.6、运行结果

同时，观察者还可以通过收到的不同信息进行解析，然后做出不同的动作

1.3、监听器设计模式

监听器设计模式，是观察者设计模式的一种实现，它并不是 23 种设计模式之一。这里的监听器实际对应的就是观察者，而被监听对象，则是指被观察者。当被监听对象的状态发生改变时，也需要通知监听器，监听器在收到通知后会做出相应改变。

与观察者设计模式不同的是，被监听者的状态改变，被定义为了一个对象，称为事件。

被监听对象有了个新的名子，称为事件源
对监听器的通知，称为触发监听器

其实质与观察者设计模式是相同的。下面以对被监听者所执行的增删改查 CURD 操作进行监听为例，来演示监听器设计模式的用法。

1.3.1、定义事件接口

一般情况下，监听器对象被事件触发后，都是需要从事件中获取到事件源对象，然后再从事件源中获取一些数据。也就是说，在事件对象中一般是需要提供获取事件源对象的方法的。当然，除了获取事件源的方法外，根据业务需求，事件对象一般还需要提供一些其它数据，以便让监听器获取。

package com.bjpowernode.events;

import com.bjpowernode.listenerable.IListenerable;

// 定义增删改查事件
// C：Create，增加
// U：Update，修改
// R：Retrieve，检索
// D：Delete，删除

// 通常，对于事件对象，我们一般是需要从事件对象中获取到事件源对象的
public interface ICurdEvent {
	// 声明事件类型
	String CRE_EVENT = "create event";
	String UPD_EVENT = "update event";
	String RET_EVENT = "retrieve event";
	String DEL_EVENT = "delete event";
	
	// 获取事件源对象
	IListenerable getEventSource();
	// 获取事件类型
	String getEventType();
}

公共静态变量使用大写字母

1.3.2、定义监听器接口

package com.bjpowernode.listeners;

import com.bjpowernode.events.ICurdEvent;

// 监听器接口
public interface IListener {
	// 处理事件
	void handle(ICurdEvent event);
}

1.3.3、定义事件源接口

因为只有一个监听器，所以使用set，不是add

1.3.4 、定义事件类

package com.bjpowernode.events;

import com.bjpowernode.listenerable.IListenerable;

// 定义事件类
public class CurdEvent implements ICurdEvent {
	private IListenerable eventSource;  // 事件源
	private String methodName;          // 事件源所执行的方法名称
	
	public CurdEvent(IListenerable eventSource, String methodName) {
		super();
		this.eventSource = eventSource;
		this.methodName = methodName;
	}

	@Override
	public IListenerable getEventSource() {
		return eventSource;
	}

	// 根据事件源所执行的不同的方法，返回不同的事件类型
	@Override
	public String getEventType() {
		String eventType = null;
		if(methodName.startsWith("save")) {
			eventType = CRE_EVENT;
		} else if(methodName.startsWith("remove")) {
			eventType = DEL_EVENT;
		} else if(methodName.startsWith("modify")) {
			eventType = UPD_EVENT;
		} else if(methodName.startsWith("find")) {
			eventType = RET_EVENT;
		} else {
			eventType = "have not this event type";
		}
		return eventType;
	}

}

1.3.5、定义监听器

package com.bjpowernode.listeners;

import com.bjpowernode.events.ICurdEvent;

// 定义监听器类
public class CurdListener implements IListener {

	@Override
	public void handle(ICurdEvent event) {
		String eventType = event.getEventType();
		if(ICurdEvent.CRE_EVENT.equals(eventType)) {          // 若事件类型为“添加”
			System.out.println("事件源执行了 添加 操作");
		} else if(ICurdEvent.DEL_EVENT.equals(eventType)) {   // 若事件类型为“删除”
			System.out.println("事件源执行了 删除 操作");
		} else if(ICurdEvent.UPD_EVENT.equals(eventType)) {   // 若事件类型为“修改”
			System.out.println("事件源执行了 修改 操作");
		} else if(ICurdEvent.RET_EVENT.equals(eventType)) {   // 若事件类型为“查询”
			System.out.println("事件源执行了 查询 操作");
		}
	}

}

1.3.6、定义事件源

1.3.7、定义测试类

1.3.8、运行结果

1.3.9、再定义事件源

事件源是拥有自己的业务方法的，本例的业务方法为增删改查。应该是事件源对象在执行这些业务方法时触发监听器，而并非是前面测试类那么使用监听器。

所以这里需要为事件源添加业务方法，在业务方法中触发监听器。

package com.bjpowernode.listenerable;

import com.bjpowernode.events.CurdEvent;
import com.bjpowernode.events.ICurdEvent;
import com.bjpowernode.listeners.IListener;

// 定义事件源类
public class Some implements IListenerable {
	private IListener listener;
	
	// 注册监听器
	@Override
	public void setListener(IListener listener) {
		this.listener = listener;
	}

	// 触发监听器
	@Override
	public void triggerListener(ICurdEvent event) {
		listener.handle(event);
	}
	
	// 下面的方法中事件源类真正的业务逻辑，而监听器监听的就是这些业务方法的执行
	public void saveStudent() {
		System.out.println("向DB中插入了一条数据");
		ICurdEvent event = new CurdEvent(this, "saveStudent");
		this.triggerListener(event);
	}
	public void removeStudent() {
		System.out.println("从DB中删除了一条数据");
		ICurdEvent event = new CurdEvent(this, "removeStudent");
		this.triggerListener(event);
	}
	public void mofidyStudent() {
		System.out.println("修改了DB中的一条数据");
		ICurdEvent event = new CurdEvent(this, "mofidyStudent");
		this.triggerListener(event);
	}
	public void findStudent() {
		System.out.println("从DB中执行了查询");
		ICurdEvent event = new CurdEvent(this, "findStudent");
		this.triggerListener(event);
	}

}

1.3.10、再定义测试类

package com.bjpowernode.test;

import com.bjpowernode.listenerable.Some;
import com.bjpowernode.listeners.CurdListener;
import com.bjpowernode.listeners.IListener;

public class MyTest {

	public static void main(String[] args) {
		
		// 定义监听器
		IListener listener = new CurdListener();
		
		// 定义事件源
		Some some = new Some();
		
		// 事件源注册监听器
		some.setListener(listener);
		
		// 事件源执行自己的业务方法
		some.saveStudent();
		some.removeStudent();
		some.mofidyStudent();
		some.findStudent();
	}

}

2、监听器 Listener

2.1、Servlet 规范中的监听器

Servlet 规范中已经定义好了八个监听器接口，它们要监听的对象分别是 request、session、servletContext 对象，触发监听器的事件是这三个对象的创建与销毁，它们的域属性空间中属性的添加、删除、修改，及 session 的钝化与活化操作。

在 JavaWeb 项目中使用监听器，需要在 web.xml 文件中对监听器进行注册。

下面分别对这八个监听器进行学习。

2.1.1、ServletRequestListener

该监听器用于完成对 Request 对象的创建及销毁的监听，即当 Request 对象被创建或被销毁时，会触发该监听器中相应方法的执行。

|定义监听器

注册监听器

2.1.2、ServletRequestAttributeListener

该监听器用于完成对 request 域属性空间中属性的添加、修改、删除操作的监听。

定义监听器

注意 ServletRequestAttributeEvent 事件的方法 getName()可以获取到被操作的属性名，方法 getValue()可以获取到被操作的属性的值。

package com.bjpowernode.listeners;

import javax.servlet.ServletRequestAttributeEvent;
import javax.servlet.ServletRequestAttributeListener;

public class MyRequestAttributeListener implements ServletRequestAttributeListener {
	// 当向request域中 添加 属性时会触发该方法的执行
	@Override
	public void attributeAdded(ServletRequestAttributeEvent srae) {
		System.out.println("向request域中添加了一个属性：" + srae.getName() + " = " + srae.getValue());
	}
	
	// 当向request域中 删除 属性时会触发该方法的执行
	@Override
	public void attributeRemoved(ServletRequestAttributeEvent srae) {
		System.out.println("从request域中删除了一个属性：" + srae.getName() + " = " + srae.getValue());
	}
	
	// 当向request域中 重置 属性时会触发该方法的执行
    //获得的是修改前的值
	@Override
	public void attributeReplaced(ServletRequestAttributeEvent srae) {
		System.out.println("修改了request域中的一个属性：" + srae.getName() + " = " + srae.getValue());
	}
}

注册监听器

修改 index.jsp 页面

2.1.3、HttpSessionListener

该监听器用于完成对 Session 对象的创建及销毁的监听。

定义监听器

package com.bjpowernode.listeners;

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MySessionListener implements HttpSessionListener {
	// 当Session被创建时触发该方法的执行
	@Override
	public void sessionCreated(HttpSessionEvent se) {
		System.out.println("Session被创建");
	}
	
	// 当Session被销毁时触发该方法的执行
	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		System.out.println("Session被销毁");
	}
}

只有内置页面一创建，Session同时也被创建了，监听器就会触发

注册监听器

修改 index.jsp 页面

Session的销毁，可以通过两种方式：

一种是设置时效，时间到自动销毁
还有是通过代码强制销毁 invalidate()

2.1.4、HttpSessionAttributeListener

该监听器用于完成对 session 域属性空间中属性的添加、修改、删除操作的监听。

定义监听器

package com.bjpowernode.listeners;

import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;

public class MySessionAttributeListener implements HttpSessionAttributeListener {
	// 当向Session域中添加属性时触发该方法的执行
	@Override
	public void attributeAdded(HttpSessionBindingEvent se) {
		System.out.println("向Session中添加了属性：" + se.getName() + " = " + se.getValue());
	}
	
	// 当从Session域中删除属性时触发该方法的执行
	@Override
	public void attributeRemoved(HttpSessionBindingEvent se) {
		System.out.println("从Session中删除了属性：" + se.getName() + " = " + se.getValue());
	}
	
	// 当重置Session域中属性值时触发该方法的执行
	@Override
	public void attributeReplaced(HttpSessionBindingEvent se) {
		System.out.println("重置了Session中的属性：" + se.getName() + " = " + se.getValue());
	}
}

注册监听器

修改 index.jsp 页面

2.1.5、ServletContextListener

该监听器用于完成对 ServletContext 对象的创建及销毁的监听。不过需要注意，由于ServletContext 在一个应用中只有一个，且是在服务器启动时创建。另外，ServletConetxt 的生命周期与整个应用的相同，所以当项目重新部署，或 Tomcat 正常关闭（通过 stop service关闭，不能是 terminate 关闭）时，可以销毁 ServletContext。

定义监听器

package com.bjpowernode.listeners;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyServletContextListener implements ServletContextListener {
	// 当ServletContext被初始化时会触发该方法的执行
	@Override
	public void contextInitialized(ServletContextEvent sce) {
		System.out.println("ServletContext被创建");
	}
	
	// 当ServletContext被销毁时会触发该方法的执行
	@Override
	public void contextDestroyed(ServletContextEvent sce) {
		System.out.println("ServletContext被销毁");
	}as
}

注册监听器

2.1.6、ServletContextAttributeListener

定义监听器

package com.bjpowernode.listeners;

import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;

public class MyServletContextAttributeListener implements ServletContextAttributeListener {
	// 当向ServletContext域中添加属性时会触发该方法的执行
	@Override
	public void attributeAdded(ServletContextAttributeEvent scae) {
		System.out.println("向ServletContext中添加了属性：" + scae.getName() + " = " + scae.getValue());
	}
	
	// 当从ServletContext域中删除属性时会触发该方法的执行
	@Override
	public void attributeRemoved(ServletContextAttributeEvent scae) {
		System.out.println("从ServletContext中删除了属性：" + scae.getName() + " = " + scae.getValue());
	}
	
	// 当重置ServletContext域中属性时会触发该方法的执行
	@Override
	public void attributeReplaced(ServletContextAttributeEvent scae) {
		System.out.println("重置了ServletContext中的属性：" + scae.getName() + " = " + scae.getValue());
	}
}

注册监听器

修改 index.jsp 页面

2.1.7、HttpSessionBindingListener

该监听器用于监听指定类型对象与 Session 的绑定与解绑，即该类型对象被放入到Session 域中，或从 Session 域中删除该类型对象，均会引发该监听器中相应方法的执行。

它与 HttpSessionAttributeListener 的不同之处是，该监听器监听的是指定类型的对象在Session 域中的操作， HttpSessionAttributeListener 监听的是 Session 域属性空间的变化，而无论是什么类型的对象。

另外，需要强调两点：

该监听器是由实体类实现
该监听器无需在 web.xml 中注册

定义实现监听器接口的实体类

package com.bjpowernode.beans;

import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

// 实体类实现HttpSessionBindingListener接口
// 该监听器是不需要注册的
public class Student implements HttpSessionBindingListener {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	// 当当前类的对象绑定到Session时（放入到Session域中）会触发该方法的执行
	@Override
	public void valueBound(HttpSessionBindingEvent event) {
		System.out.println("student对象放入到了Session域");
		System.out.println(event.getName() + " = " + event.getValue());
	}
	
	// 当当前类的对象与Session解绑时（从Session域中删除）会触发该方法的执行
	@Override
	public void valueUnbound(HttpSessionBindingEvent event) {
		System.out.println("student对象从Session域中删除");
		System.out.println(event.getName() + " = " + event.getValue());
	}
}

修改 index.jsp 页面

运行结果

2.1.8、HttpSessionActivationListener

该监听器用于监听在 Session 中存放的指定类型对象的钝化与活化。

钝化是指将内存中的数据写入到硬盘中，而活化是指将硬盘中的数据恢复到内存。

当用户正在访问的应用或该应用所在的服务器由于种种原因被停掉，然后在短时间内又重启，此时用户在访问时 Session 中的数据是不能丢掉的，在应用关闭之前，需要将数据写入到硬盘，在重启后应可以立即重新恢复 Session 中的数据。这就称为 Session 的钝化与活化。

那么 Session 中的哪些数据能够钝化呢？只有存放在 JVM 堆内存中的实现了 Serializable类的对象能够被钝化。也就是说，对于字符串常量、基本数据类型常量等存放在 JVM 方法区中常量池中的常量，是无法被钝化的。

对于监听 Session 中对象数据的钝化与活化，需要注意以下几点：

实体类除了要实现 HttpSessionActivationListener 接口外，还需要实现 Serializable 接口。
钝化指的是 Session 中对象数据的钝化，并非是 Session 的钝化。所以 Session 中有几个可以钝化的对象，就会发生几次钝化。
HttpSessionActivationListener 监听器是不需要在 web.xml 中注册的。

定义实现监听器接口的实体类

package com.bjpowernode.beans;

import java.io.Serializable;

import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionEvent;

// 实体类实现HttpSessionActivationListener接口，同时还要实现Serializable接口
// 该监听器是不需要注册的
public class Student implements HttpSessionActivationListener, Serializable {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	// 当当前类的对象被活化（硬盘中的数据恢复到内存）时会触发该方法的执行
	@Override
	public void sessionDidActivate(HttpSessionEvent se) {
		System.out.println("Student已经活化");
	}
	
	// 当当前类的对象被钝化（内存中的数据写入到硬盘）时会触发该方法的执行
	@Override
	public void sessionWillPassivate(HttpSessionEvent se) {
		System.out.println("Student将要被钝化");
	}
}

修改 index.jsp 页面

2.2、监听器应用举例

2.2.1、在线客户端统计

统计连接在应用上的客户端数量。客户端的唯一标识就是 IP，只需要将连接到服务器上的 IP 数量进行统计，就可统计出客户端的数量。这里需要注意一些细节：

从 Request 中可以获取到请求的 IP，而从 Session 中是获取不到的。
从 Session 中是无法获取到 Request 对象的，因为 session 与 request 的关系是 1:n，即一个会话中可以包含多个请求。
一个客户端可以发出很多请求与会话，但从这些请求中获取到的 IP 都是相同的。可以将获取到的 IP 放入到 Map 集合中，且以 IP 为 key，可以保证集合中没有重复的 IP。而value 则为该 IP 的机器上所发出的会话对象所组成的 List。
当一个客户端的 Session 被销毁时，应从 map 的当前 ip 所对应的 value 中，即 List 中删除当前的 Session 对象。然后再查看 Map 中该客户端 IP 所发出的会话 List 长度，若为 0，则可将该 IP 所对应的 Entry 对象从 Map 中删除。

1、获取访问请求次数

从简单开始

MyRequestListener.java 请求监控器

package com.ssxxz.listeners;

import javax.servlet.ServletContext;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
	//监听器
public class MyRequestListener implements ServletRequestListener {
	//获取请求的对象,并记录
	@Override
	public void requestInitialized(ServletRequestEvent sre) {
		//利用全局域变量，就算访问次数
		//获取全局域
		ServletContext sc = sre.getServletContext();
		//获取全局域中指定的访问值
		Integer count = (Integer)sc.getAttribute("count");
		count++;
		sc.setAttribute("count", count);
	}
}

MyServletContextListener.java 全局域监控器，创建变量记录访问次数

package com.ssxxz.listeners;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
//全局域变量，计算访问次数,方便调用
public class MyServletContextListener implements ServletContextListener {
	
	@Override //初始化方法
	public void contextInitialized(ServletContextEvent sce) {
		Integer count = 0;	//统计值初始化
		ServletContext sc = sce.getServletContext();	//获取域
		sc.setAttribute("count", count);	//将统计值传入域中
	}
}

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>




Insert title here


	
	本页面浏览量为 ${applicationScope.count} 次

web.xml


<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://JAVA.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>clientCountdisplay-name>
  
  <listener>
  	<listener-class>com.ssxxz.listeners.MyServletContextListenerlistener-class>
  listener>
    
  <listener>
  	<listener-class>com.ssxxz.listeners.MyRequestListenerlistener-class>
  listener>
  
  <welcome-file-list>
    <welcome-file>index.jspwelcome-file>
  welcome-file-list>
web-app>

2、获取浏览器会话次数

将MyRequestListener.java 的计算内容放到新建的 MyRequestListener.java 内

新建 MyRequestListener.java 会话监控器

package com.ssxxz.listeners;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MySessionListener implements HttpSessionListener {
	//浏览器,开启一个新浏览器会话
	@Override
	public void sessionCreated(HttpSessionEvent se) {
		System.out.println("=============");
		//利用全局域变量，就算访问次数
				//获取全局域
				ServletContext sc = se.getSession().getServletContext();
				//获取全局域中指定的访问值
				Integer count = (Integer)sc.getAttribute("count");
				count++;
				sc.setAttribute("count", count);
	}
}

3、获取IP次数，初次编写

因为 IP 只能从请求里获取，所以删除MyRequestListener.java 会话监听器，在MyRequestListener请求监听器中编写代码

package com.ssxxz.listeners;

import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
	//监听器
public class MyRequestListener implements ServletRequestListener {
	//获取请求的对象，并记录
	@Override
	public void requestInitialized(ServletRequestEvent sre) {
		//请求里获取ip
		ServletRequest request = sre.getServletRequest();
		//getRemoteAddr() 获取远程地址IP
		String clientIp = request.getRemoteAddr();
		
		//获取全局域
		ServletContext sc = sre.getServletContext();
		//获取全局域集合总数
		List<String> ips =(List<String>)sc.getAttribute("ips");
		//遍历比对获得的Ip在集合中的是否存在
		for (String ip : ips) {
			if (clientIp.equals(ip)) {
				return;
			}
		}
		//遍历没有的，加入ips内
		ips.add(clientIp);
		//更新全局域中的集合
		sc.setAttribute("ips", ips);
		
	}
}

MyServletContextListener 全局域，将总数从int类型改成list集合

package com.ssxxz.listeners;

import java.util.List;
import java.util.ArrayList;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
//全局域变量，计算访问次数,方便调用
public class MyServletContextListener implements ServletContextListener {
	
	@Override //初始化方法
	public void contextInitialized(ServletContextEvent sce) {
		//将int类型换成list集合，记录进来的IP
		List<String> ips = new ArrayList<>();
		
		ServletContext sc = sce.getServletContext();	//获取域
		sc.setAttribute("ips", ips);	//将统计值传入域中
	}
}

同一电脑测试多ip方式：

http://localhost:8080/clientCount/

http://127.0.0.1:8080/clientCount/

http://以太网地址:8080/clientCount/

4、id退出，让 session 失效，并且删除id

index 添加一个退出功能

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>




Insert title here


	
	您是第 ${applicationScope.ips.size()} 位访客 

	安全退出

创建一个session失效的方法LogoutServlet

package com.ssxxz.Servlets;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
//使session失效
public class LogoutServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response) 
			throws ServletException, IOException {
		//获取session,没有session也不创建session
		HttpSession session = request.getSession(false);
		if (session != null) {
			//强行失效
			session.invalidate();
		}
		
	}
}

session 失效后删除id

但是 session无法直接获得id，所有需要使用request将ip存于session域中，再从域中调取删除

package com.ssxxz.listeners;

import java.util.List;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MySessionListener implements HttpSessionListener {
	
	//如果session失效
	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		//Requeest里将Ip加入到session域中，再从域中获取
		HttpSession session = se.getSession();
		String clientIp = (String)session.getAttribute("clientIp");
		
		ServletContext sc = se.getSession().getServletContext();
		List<String> ips = (List<String>)sc.getAttribute("ips");
		//ip在请求里，而因为session里有无数个请求，无法获取到指定的ip，所以只能在请求里删除ip
		//域中获取后再删除
		ips.remove(clientIp);
		
	}
}

利用 request 调用ip存入域中

package com.ssxxz.listeners;

import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.websocket.Session;
	//监听器
public class MyRequestListener implements ServletRequestListener {
	//获取请求的对象，并记录
	@Override
	public void requestInitialized(ServletRequestEvent sre) {
		//请求里获取ip
		HttpServletRequest request = (HttpServletRequest)sre.getServletRequest();
		//getRemoteAddr() 获取远程地址IP
		String clientIp = request.getRemoteAddr();
		
		//Request里可以获取ip也可以获取Session，所以在这里将ip放入session域
		//getHeader()， getMethod() ， getSession() 需要HttpServletRequest接口
		HttpSession session =  request.getSession();
		session.setAttribute("clientIp", clientIp);
		
		System.out.println("clientIp =" + clientIp);
		//获取全局域
		ServletContext sc = sre.getServletContext();
		//获取全局域集合总数
		List<String> ips =(List<String>)sc.getAttribute("ips");
		//遍历比对获得的Ip在集合中的是否存在
		for (String ip : ips) {
			if (clientIp.equals(ip)) {
				return;
			}
		}
		//遍历没有的，加入ips内
		ips.add(clientIp);
		//更新全局域中的集合
		sc.setAttribute("ips", ips);
	
	}
}

但是有个问题，比如：同时3个ip在线，其中有一个ip有2个在线会话。当失效一个，其他ip的显示数会为2（3-1个），但是它的另一个ip还是显示3个ip在线，此时就出现了一个bug。实际上还是3个ip在线，但是其他ip显示为2个。

5、解决4号问题，最终版

是因为，当session失效时，程序立刻删除了ip，并没有查询该ip是否还有其他会话存在

定义 ServletContext 监听器

在 ServletContext 初始化时创建用于存放 IP 信息的 Map 集合，并将创建好的 Map 存放到 ServletContext 域中。

Map 的 key 为客户端 IP，而 value 则为该客户端 ip 所发出的会话对象组成的 List。

package com.bjpowernode.listeners;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;

public class MyServletContextListener implements ServletContextListener {
	@Override
	public void contextInitialized(ServletContextEvent sce) {
		// 创建一个Map，key为ip，value为该ip上所发出的会话对象
		Map<String, List<HttpSession>> map = new HashMap<>();
		// 获取ServletContext，即全局域对象
		ServletContext sc = sce.getServletContext();
		// 将map放入到全局域中
		sc.setAttribute("map", map);
	}
}

定义 Request 监听器

Request 监听器主要完成以下功能：

获取当前请求的客户端的 IP
获取当前 IP 所对应的全局域中的 List。若这个 List 为空，则创建一个 List。
将当前 IP 放入到 List 中，并将当前 IP 与 List 写入到 Map 中，然后再重新将 Map 写回ServletContext 中
将当前 IP 存放到当前请求所对应的 Session 域中，以备在 Session 销毁时使用

package com.bjpowernode.listeners;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

public class MyRequestListener implements ServletRequestListener {
	
	// 主要目标将当前Session对象存放到List中
	@Override
	public void requestInitialized(ServletRequestEvent sre) {
		// 获取当前request
		HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
		// 获取当前ip
		String clientIp = request.getRemoteAddr();
		// 获取当前session对象
		HttpSession currentSession = request.getSession();
		
		//获取全局域
		ServletContext sc = sre.getServletContext();
		// 从全局域中获取map
		Map<String, List<HttpSession>> map = (Map<String, List<HttpSession>>) sc.getAttribute("map");
		// 从Map中获取由当前IP所发出的所有Session组成的List
		List<HttpSession> sessions = map.get(clientIp);
		// 判断当前的List是否为null。若为null，则创建List。
		if(sessions == null) {
			sessions = new ArrayList<>();
		}
		
		// 遍历List。若List中存在当前Session对象，则不用操作List
		for (HttpSession session : sessions) {
			if(session == currentSession) {
				return;
			}
		}
		// 将当前Session放入到这个List
		sessions.add(currentSession);
		
		// 将变化过的List重新写回到map
		map.put(clientIp, sessions);
		// 将变化过的map重新写回到全局域
		sc.setAttribute("map", map);
		
		// 将当前ip放入到当前Session
		currentSession.setAttribute("clientIp", clientIp);
	}
}

定义 Session 监听器

该监听器的功能主要是，当 Session 被销毁时，将当前 Session 对象从 List 中删除。在从List 删除后，若 List 中没有了元素，则说明这个 IP 所发出的会话已全部关闭，则可以将该 IP所对应的 Entry 从 map 中删除了。 List 中仍有元素，若则将变化过的 List 重新再写入回 map。

package com.bjpowernode.listeners;

import java.util.List;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
 
public class MySessionListener implements HttpSessionListener {
	
	// 将当前Session对象从List中删除
	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		// 获取当前Session对象
		HttpSession currentSession = se.getSession();
		// 从当前Session中获取当前ip
		String clientIp = (String) currentSession.getAttribute("clientIp");
		// 获取全局域
		ServletContext sc = currentSession.getServletContext();
		// 从全局域中获取map
		Map<String, List<HttpSession>> map = (Map<String, List<HttpSession>>) sc.getAttribute("map");
		// 从Map中获取List
		List<HttpSession> sessions = map.get(clientIp);
		// 从List中删除当前Session对象
		sessions.remove(currentSession);
		// 若List中没有了元素，则说明当前IP所发出的会话全部关闭，那么就可以从map中将当前ip所对应的Entry对象删除
		// 若List中仍有元素，则说明当前IP所发出的会话还存在，那么将这个变化过的List写回到map
		if(sessions.size() == 0) {
			map.remove(clientIp);
		} else {
			map.put(clientIp, sessions);
		}
		// 将变化过的map写回到全局域
		sc.setAttribute("map", map);
		
	}
}

注册监听器


<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <listener>
    <listener-class>com.bjpowernode.listeners.MyRequestListenerlistener-class>
  listener>
  <listener>
    <listener-class>com.bjpowernode.listeners.MyServletContextListenerlistener-class>
  listener>
  <listener>
    <listener-class>com.bjpowernode.listeners.MySessionListenerlistener-class>
  listener>
  <welcome-file-list>
    <welcome-file>index.jspwelcome-file>
  welcome-file-list>
  <servlet>
    <description>description>
    <display-name>LogoutServletdisplay-name>
    <servlet-name>LogoutServletservlet-name>
    <servlet-class>com.bjpowernode.servlets.LogoutServletservlet-class>
  servlet>
  <servlet-mapping>
    <servlet-name>LogoutServletservlet-name>
    <url-pattern>/logoutServleturl-pattern>
  servlet-mapping>
web-app>

定义 index.jsp 页面

遍历map导入jar包

<%@ page pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>




Insert title here


	您是第${map.size() }位访客。

	安全退出
	
	

	
	
		${entry.key } = ${entry.value.size() }

定义 LogoutServlet

package com.bjpowernode.servlets;

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

public class LogoutServlet extends HttpServlet {
	protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		HttpSession session = request.getSession(false);
		if(session != null) {
			session.invalidate();
		}
		
	}

}

2.2.2、管理员踢除用户

论坛管理员对于一些不守规矩的登录用户可以进行踢除。这里要完成的就是这个功能。

这里有些细节需要注意：

什么是用户已经登录？就是用户信息写入到了 Session 中。
什么是对用户的踢除？就是使该用户信息所绑定的 Session 失效。
若要完成这个踢除功能，管理员首先应该可以看到所有在线用户。那么在线用户信息就应该保存在一个集合中。
这个集合既应该有用户信息，又应该有与用户信息绑定的 Session 对象。这样便于管理员获取到某一用户的 Session 后，将其失效。所以这个集合选用 Map，key 为用户名（各站点都要求用户名是不能重复的，原因就是这个），value 为与该用户绑定的 Session。
这个 Map 集合中的数据应该在什么时候放进去？只要发生 User 对象与 Session 的绑定操作，就说明有用户登录。此时就应将数据放入到 Map 中。也就是说，应该为实体类User 实现 Session 绑定监听器 HttpSessionBindingListener。
这个 Map 集合应该什么时候创建？应该在应用启动时就创建，即在 ServletConetxt 被初始化时被创建。所以应该定义一个 ServletContext 监听器 ServletContextListener，在ServletContext 被初始化时创建这个 Map 集合。

1、文案代码

定义用户登录页面 index.jsp

定义实体类 User

只要发生 User 对象与 Session 的绑定操作，就说明有用户登录。此时就应将数据放入到Map 中。也就是说，实体类 User 应实现 Session 绑定监听器 HttpSessionBindingListener。

定义 ServletContext 监听器

注册 ServletContext 监听器

定义 LoginServlet

用户提交登录表单后，马上与 Session 进行绑定，以便将信息写入到 Map 中

注册 LoginServlet

定义 welcome.jsp 页面

定义用户列表页面 userList.jsp

这其中用到了显示序号、隔行着色。而这些功能的完成，是由的 varStatus属性配合着完成的。

定义 DeleteServlet

这里需要注意的是，当将当前 user 的 Session 失效后，还需要将当前 user 对应的 Entry对象从 Map 中删除，否则，userList 页面的列表中仍然会显示这个用户。因为 Map 仍存在，只不过该 session 失效而已。

将指定用户踢除后，重新返回到 userList 页面，显示更新过的列表。

注册 DeleteServlet

2、视频代码

login.jsp 登录界面

<%@ page pageEncoding="UTF-8"%>




Insert title here


	
		姓名：

		年龄：

welcome 欢迎页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>




Insert title here


	welcome page

User.java

用户属性的实现类，进行User对象和Session对象的绑定

package com.ssxxz.beans;

import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

public class User implements HttpSessionBindingListener {
	//实体类用户属性
	private String name;
	private int age;
	
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}
	
	//当User对象和Session对象进行绑定时，将用户名和Session对象放到map里存储起来
	@Override
	public void valueBound(HttpSessionBindingEvent event) {
		//获取当前的Session
		HttpSession session = event.getSession();
		//获取全局域
		ServletContext sc = session.getServletContext();
		//从全局域中获取map
		Map<String, HttpSession> map = (Map<String, HttpSession>)sc.getAttribute("map");
		//将当前用户名与Session放到map中
		map.put(name, session);
		//将map写回到全局域中
		sc.setAttribute("map", map);	
	}
}

MyServletContextListener.java

创建一个存储用户信息的map，并放到全局域中方便调用

package com.ssxxz.listeners;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;

public class MyServletContextListener implements ServletContextListener {
	//应用启动时，创建map，存储用户信息
	@Override
	public void contextInitialized(ServletContextEvent sce) { 
		//创建一个Map,key为用户名，value为与当前用户绑定的Session对象
		Map<String, HttpSession> map = new HashMap<>();
		//获取到全局域
		ServletContext sc = sce.getServletContext();
		//将map放入到全局域中，方便其他地方调用
		sc.setAttribute("map",map);
	}
}

LoginServlet.java

中文解码，并将用户放入map中

package com.ssxxz.Servlet;

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

import com.ssxxz.beans.User;

public class LoginServlet extends HttpServlet {
       
	protected void doPost(HttpServletRequest request, HttpServletResponse response) 
			throws ServletException, IOException {
		//解决乱码问题，获得用户提交的请求参数
		request.setCharacterEncoding("UTF-8");
		String name = request.getParameter("name");
		String ageStr = request.getParameter("age");
		Integer age = Integer.valueOf(ageStr);	//String转int
		//创建User对象
		User user = new User(name,age);
		
		//获取当前请求对应的Session
		HttpSession session = request.getSession();
		
		// 将User与Serssion绑定
		session.setAttribute("user", user);
		
		//登录跳转到欢迎页面
		response.sendRedirect(request.getContextPath()+"/welcome.jsp");	
	}
}

List.jsp 管理员页面

实现查看及剔除功能

<%@ page pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>




Insert title here


	
			
		已登录用户	
		
			用户名
			Session
			踢除
		
		
				${entry.key }
				${entry.value }
				踢除

已登录用户
用户名	Session	踢除
${entry.key }	${entry.value }	踢除

KickServlet.java

管理员剔除动作

package com.ssxxz.Servlet;

import java.io.IOException;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class KickServlet extends HttpServlet {

	protected void doGet(HttpServletRequest request, HttpServletResponse response) 
			throws ServletException, IOException {
		//注意不能直接失效本地Session，需要失效map里的Session
		//获取全局域，获得map 	
		ServletContext sc = request.getSession().getServletContext();
		Map<String, HttpSession> map = (Map<String, HttpSession>) sc.getAttribute("map");
		
		//获取请求中传入的要剔除的用户名
		String name = request.getParameter("name");
		//从map中获取当前用户所对应的Session
		HttpSession session = map.get(name);
		//然后使map中的session失效
		session.invalidate();
		//将该用户对应的Entry从map中删除
		map.remove(name);
		
		//返回 index 页面
		request.getRequestDispatcher("/index.jsp").forward(request, response);
	}
}

web.xml


<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://JAVA.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>kickUserdisplay-name>
  <listener>
    <listener-class>com.ssxxz.listeners.MyServletContextListenerlistener-class>
  listener>
  <welcome-file-list>
    <welcome-file>index.jspwelcome-file>
  welcome-file-list>
  <servlet>
    <description>description>
    <display-name>LoginServletdisplay-name>
    <servlet-name>LoginServletservlet-name>
    <servlet-class>com.ssxxz.Servlet.LoginServletservlet-class>
  servlet>
  <servlet-mapping>
    <servlet-name>LoginServletservlet-name>
    <url-pattern>/loginServleturl-pattern>
  servlet-mapping>
  <servlet>
    <description>description>
    <display-name>KickServletdisplay-name>
    <servlet-name>KickServletservlet-name>
    <servlet-class>com.ssxxz.Servlet.KickServletservlet-class>
  servlet>
  <servlet-mapping>
    <servlet-name>KickServletservlet-name>
    <url-pattern>/kickServleturl-pattern>
  servlet-mapping>
web-app>

测试时注意，输入往一个用户时，你如果返回重写输入另外一个用户，此刻两个用户就会出现同时使用一个session的情况。当你要删除完第一个用户，session会同时失效，再删除另一个时，此时session已经失效，系统会报错。所以我们测试这个时需要用其他浏览器登录另外一个用户。

你可能感兴趣的:(java,eclipse,java)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
算法单链的创建与删除换个号韩国红果果 c 算法
先创建结构体 struct student { int data; //int tag;//标记这是第几个 struct student *next; }; // addone 用于将一个数插入已从小到大排好序的链中 struct student *addone(struct student *h,int x){ if(h==NULL) //??????
《大型网站系统与Java中间件实践》第2章读后感白糖_ java中间件
断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。看完整章内容，
zeus持久层spring事务单元测试 deng520159 java DAO spring jdbc
今天把zeus事务单元测试放出来,让大家指出他的毛病, 1.ZeusTransactionTest.java 单元测试 package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Test; import
Rss 订阅开发周凡杨 html xml 订阅 rss 规范
RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。 RSS
分页查询实现 g21121 分页查询
在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。按实现形式分前台分页和服务器分页：前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
spring jms异步消息处理 510888780 jms
spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下：
highCharts柱状图布衣凌宇 hightCharts 柱图
第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller @Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController { private UserServi
我的spring学习笔记2-IoC（反向控制依赖注入） aijuans spring mvc Spring 教程 spring3 教程 Spring 入门
IoC（反向控制依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
TLS java简单实现 antlove java ssl keystore tls secure
1. SSLServer.java package ssl; import java.io.FileInputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.security.KeyStore; import
Zip解压压缩文件百合不是茶 Zip格式解压 Zip流的使用文件解压
ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件; ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName)); &n
underscore.js 学习（一） bijian1013 JavaScript underscore
工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。学
java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon) bijian1013 java jvm jstatd
1.介绍 jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。 jstatd是基于RMI的，所以在运行jstatd的服务
【Spring框架三】Spring常用注解之Transactional bit1129 transactional
Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义： /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version
我(程序员)的前进方向 bitray 程序员
作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
nginx lua开发经验总结 ronin47
使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下 1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶 bylijinnan java
import java.util.Stack; public class ReverseStackRecursive { /** * Q 66.颠倒栈。 * 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。 * 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。 *1. Pop the top element *2. Revers
正确理解Linux内存占用过高的问题 cfyme linux
Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上： Mem: 3889836k total, 3341868k used, 547968k free, 286044k buffers Swap: 6127608k total,&nb
[JWFD开源工作流]当前流程引擎设计的一个急需解决的问题 comsci 工作流
当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
自定义类的equals函数 dai_lm equals
仅作笔记使用 public class VectorQueue { private final Vector<VectorItem> queue; private class VectorItem { private final Object item; private final int quantity; public VectorI
Linux下安装R语言 datageek R语言 linux
命令如下：sudo gedit /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
如何修改mysql 并发数(连接数)最大值 dcj3sjt126com mysql
MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了方法一：进入MYSQL安装目录打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
单一功能原则 dcj3sjt126com 面向对象的程序设计软件设计编程原则
单一功能原则[ 编辑] SOLID 原则单一功能原则开闭原则 Liskov代换原则接口隔离原则依赖反转原则查论编在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
POJO、VO和JavaBean区别和联系 fanmingxing VO POJO javabean
POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
SpringSecurity3.X--LDAP：AD配置 hanqunfeng SpringSecurity
前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。将配置文件中的如下部分删除：
mac mysql 修改密码 IXHONG mysql
$ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
设计模式--抽象工厂模式 kerryg 设计模式
抽象工厂模式：工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
评"高中女生军训期跳楼” nannan408
首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
scala如何读取和写入文件内容？ qindongliang1922 java jvm scala
直接看如下代码： package file import java.io.RandomAccessFile import java.nio.charset.Charset import scala.io.Source import scala.reflect.io.{File, Path} /** * Created by qindongliang on 2015/
C语言算法之百元买百鸡 qiufeihu c 算法
中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？代码如下： #include <stdio.h> int main() { int cock,hen,chick; /*定义变量为基本整型*/ for(coc
Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode wyz2009107220 NameNode
正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。 1. Secondary NameNode 原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image 优点：Hadoop较早的版本都自带，