SpringBoot项目中改变web服务的路径的两种方案

  <!-- web servlet configuration -->
  <servlet>
    <servlet-name>stariboss</servlet-name>
    <servlet-class>com.osgi.web.servlet.springproxyservlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>defa</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
	<servlet-name>defa</servlet-name>
	<url-pattern>/inner-invoke/*</url-pattern>
  </servlet-mapping>
  <!-- end web servlet configuration -->

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.configuration;
import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.restcontroller;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.pathmatchconfigurer;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;
 
@configuration
public class webintfconfig implements webmvcconfigurer {
 
    @autowired
    private sessionmanagerinterceptor sessionmanagerinterceptor;
    @autowired
    private logincheckinterceptor logincheckinterceptor;
 
 
    @override
    public void configurepathmatch(pathmatchconfigurer configurer) {
        configurer.addpathprefix("/defa/inner-invoke", c -> c.isannotationpresent(controller.class) || c.isannotationpresent(restcontroller.class));
    }
 
    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(sessionmanagerinterceptor)
                .addpathpatterns("/defa/inner-invoke/**");
 
        registry.addinterceptor(logincheckinterceptor)
                .addpathpatterns("/defa/inner-invoke/**");
    }
}

import org.springframework.stereotype.component;
import org.springframework.web.servlet.handler.handlerinterceptoradapter;
 
import javax.servlet.requestdispatcher;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
 
 
@component
public class mvcrequestinterceptor extends handlerinterceptoradapter {
 
    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
        // 获取原始请求路径
        string originalpath = request.getrequesturi();
 
        // 检查请求路径并决定是否需要重定向
        if (originalpath.startswith("/defa/inner-invoke/")) {
            // 将请求重定向到新的路径
            string newpath = transformurl(originalpath);
 
            // 获取 requestdispatcher
            requestdispatcher dispatcher = request.getrequestdispatcher(newpath);
 
            // 在服务器端内部转发请求
            dispatcher.forward(request, response);
 
            // 返回 false 表示请求已被处理，不再继续
            return false;
        }
 
        // 如果不需要重定向，则继续处理请求
        return true;
    }
 
    private string transformurl(string currenturl) {
        // 这里实现url转换逻辑
        return currenturl.replace("/defa/inner-invoke/", "/");
    }
}

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.configuration;
import org.springframework.web.servlet.config.annotation.interceptorregistry;
import org.springframework.web.servlet.config.annotation.webmvcconfigurer;
 
@configuration
public class intfinterceptorconfig implements webmvcconfigurer {
 
    @autowired
    private mvcrequestinterceptor mvcrequestinterceptor;
    @autowired
    private sessionmanagerinterceptor sessionmanagerinterceptor;
    @autowired
    private logincheckinterceptor logincheckinterceptor;
 
    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(mvcrequestinterceptor).addpathpatterns("/defa/inner-invoke/**");
        registry.addinterceptor(sessionmanagerinterceptor).addpathpatterns("/**");
        registry.addinterceptor(logincheckinterceptor).addpathpatterns("/**");
    }
}

@component
public class sessionmanagerinterceptor extends handlerinterceptoradapter {
 
	private final log logger = logfactory.getlog(sessionmanagerinterceptor.class);
	
	public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
		try {
			prereadremoteinvocation(request);
			return true;
		} finally {
			prewriteremoteinvocationresult(response,handler);
		}
	}
	
	private void prereadremoteinvocation(httpservletrequest request) {
		string sessionid = request.getheader("sessionid");
 
		applicationsession appsession =null;
		if(sessionid!=null && sessionid.length()>0){
			appsession = getcache().getsession(sessionid);
			if(appsession == null){
				if (logger.iswarnenabled()) {
					logger.warn("not find session: " + sessionid);
				}
			}else{
				if (logger.isdebugenabled()) {
					logger.debug("getsession: " + sessionid);
				}
			}
		}
		
		if(appsession==null){
			appsession = applicationsession.create();
			if (logger.isdebugenabled()) {
				logger.debug("create a new session: " + appsession.getid());
			}
		}
 
		applicationsessionholder.put(appsession);
	}
 
	private void prewriteremoteinvocationresult(httpservletresponse response,object handler) {
		applicationsession appsession = applicationsessionholder.getapplicationsession();
		if (appsession != null) {
			if (applicationsessionholder.isclear() 
					&& !"login".equals(((handlermethod)handler).getmethod().getname())) {
				if (logger.isinfoenabled()) {
					logger.info("remove cache session : " + appsession.getid());
				}
				getcache().clearsession(appsession.getid());
			} else {
				appsession.updatelastaccessedtime();
				response.setheader("sessionid", appsession.getid());
				getcache().putsession(appsession);
			}
//			applicationsessionholder.remove();
		}
	}
 
	public isessioncache getcache() {
		if (beanfactoryholder.getcontext().containsbean("proxysessioncache")) {
			return (isessioncache) beanfactoryholder.getcontext().getbean("proxysessioncache");
		}
		return (isessioncache) beanfactoryholder.getcontext().getbean("sessioncache");
	}
 
}

package com.star.sms.webconfig;
 
import com.star.sms.business.core.applicationsessionholder;
import com.star.sms.business.core.beanfactoryholder;
import com.star.sms.exceptions.bossinnerserviceinvokeexception;
import com.star.sms.model.core.applicationsession;
import com.star.sms.remote.session.isessioncache;
import org.apache.commons.lang.arrayutils;
import org.springframework.stereotype.component;
import org.springframework.stereotype.service;
import org.springframework.util.stringutils;
import org.springframework.web.method.handlermethod;
import org.springframework.web.servlet.handler.handlerinterceptoradapter;
 
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
 
@component
public class logincheckinterceptor extends handlerinterceptoradapter {
 
	private string[] methods = { "login", "logout", "unlock", "getversion","getsystemparamint", "getsession","getsupplyoperatorrecordswitch" ,"agentlogin"};
	
	public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws bossinnerserviceinvokeexception {
		if (!(handler instanceof handlermethod)) {
			return true;
		}
		if (!arrayutils.contains(methods, ((handlermethod)handler).getmethod().getname()) && !islogin()) {
			string sessionid = request.getheader("sessionid");
			if (stringutils.hastext(sessionid)) {
 
				applicationsession session = getcache().getsession(sessionid);
				if (session == null || session.getattribute("operator") == null) {
		            throw bossinnerserviceinvokeexception.error("not.login");
				}else{
					session.updatelastaccessedtime();
					getcache().putsession(session);
					applicationsessionholder.put(session);
				}
			} else {
	            throw bossinnerserviceinvokeexception.error("not.login");
			}
		} 
		return true;
	}
 
 
	public static boolean islogin() {
		applicationsession session = applicationsessionholder.getapplicationsession();
		if (session == null) {
			return false;
		}
		object o = session.getattribute("operator");
		return o != null;
	}
 
 
	public isessioncache getcache() {
		if (beanfactoryholder.getcontext().containsbean("proxysessioncache")) {
			return (isessioncache) beanfactoryholder.getcontext().getbean("proxysessioncache");
		}
		return (isessioncache) beanfactoryholder.getcontext().getbean("sessioncache");
	}
}