spring 手写分三个阶段：
1.配置阶段：
web.xml配置
servlet初始化
2.初始化阶段：
加载配置文件
ioc容器初始化
扫描相关的类
类实例化，并注入ioc容器
将url路径和相关method进行映射关联
3运行阶段
dopost作为入口
根据url找到method，通过反射去运行method;
response.getWriter(().wirte();
项目结构图如下：
一.配置阶段：
项目本身是maven项目，pom文件只配了servlet-api和jetty
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.wj.Spring</groupId>
<artifactId>Spring</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.4.5.v20170502</version>
<configuration>
<scanIntervalSeconds>10</scanIntervalSeconds>
<httpConnector>
<port>8080</port>
</httpConnector>
<webApp>
<contextPath>/</contextPath>
</webApp>
</configuration>
</plugin>
</plugins>
</build>
</project>然后创建DispatcherServlet 使其继承HttpServlet,重写dopost,doGet 以及 init 方法
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
}
@Override
public void init(ServletConfig config) throws ServletException {
}配置web.xml 如下：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<servlet>
<servlet-name>demoMvc</servlet-name>
<servlet-class>com.wj.spring.mvcframework.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>application.properties</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>demoMvc</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>配置spring 核心配置文件application的路径
application.properties的内容只有一个扫描路径：
接下来配置注解：springMvc常用注解：
@Controller @Service @RequestMapping @Autowired @RequestParam
这些我们都将重写，替换成自己的注解
1）@DemoController
package com.wj.spring.mvcframework.annotation;
import java.lang.annotation.*;
/**
* Created by 小美女 on 2018/12/9.
*/
//类上使用
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DemoController {
String value() default "";
}
2)@DemoService
package com.wj.spring.mvcframework.annotation;
import java.lang.annotation.*;
/**
* Created by 小美女 on 2018/12/9.
*/
//类上使用
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DemoService {
String value() default "";
}
3) @DemoRequestMapping
package com.wj.spring.mvcframework.annotation;
import java.lang.annotation.*;
/**
* Created by 小美女 on 2018/12/9.
*/
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DemoRequestMapping {
String value() default "";
}
4)@Autowired
package com.wj.spring.mvcframework.annotation;
import java.lang.annotation.*;
/**
* Created by 小美女 on 2018/12/9.
*/
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DemoAutowired {
String value() default "";
}
5) @DemoRequestParam 该注解因为在配置时把参数名字写死了，所以下文没用上
package com.wj.spring.mvcframework.annotation;
import java.lang.annotation.*;
/**
* Created by 小美女 on 2018/12/9.
*/
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DemoRequestParam {
String value() default "";
}
创建测试类：DemoAction ; DemoServiceImpl implements MyService
1)DemoAction:
package com.wj.spring.demo.action;
import com.wj.spring.demo.service.MyService;
import com.wj.spring.mvcframework.annotation.DemoAutowired;
import com.wj.spring.mvcframework.annotation.DemoController;
import com.wj.spring.mvcframework.annotation.DemoRequestMapping;
import com.wj.spring.mvcframework.annotation.DemoRequestParam;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Created by 小美女 on 2018/12/9.
*/
@DemoController
@DemoRequestMapping("/demo")
public class DemoAction {
@DemoAutowired
private MyService myService;
@DemoRequestMapping("/query")
public void query(HttpServletRequest req, HttpServletResponse resp,@DemoRequestParam("name") String name){
String result =myService.get(name);
try {
//写入页面
resp.getWriter().write(result);
}catch (Exception e){
e.printStackTrace();
}
}
@DemoRequestMapping("/add")
public void add(HttpServletRequest req,HttpServletResponse resp,@DemoRequestParam("a") Integer a,@DemoRequestParam("b") Integer b){
try {
resp.getWriter().write(a+"+"+b+"="+(a+b));
}catch (Exception e){
e.printStackTrace();
}
}
@DemoRequestMapping("/remove")
public void remove(HttpServletRequest req,HttpServletResponse resp,@DemoRequestParam("id") Integer id){
}
}
2)MyService:
package com.wj.spring.demo.service;
/**
* Created by 小美女 on 2018/12/9.
*/
public interface MyService {
public String get(String name);
}
3) DemoServiceImpl implements MyService:
package com.wj.spring.demo.service.impl;
import com.wj.spring.demo.service.MyService;
import com.wj.spring.mvcframework.annotation.DemoService;
/**
* Created by 小美女 on 2018/12/9.
*/
@DemoService
public class DemoServiceImpl implements MyService {
public String get(String name) {
return "my name is :"+name;
}
}
2.初始化阶段：
在DispatcherServlet中添加成员变量；
当web项目启动时，会启动Servlet容器并加载DispatcherServlet 的init（）方法，从init()方法的参数中，我们可以拿到application.properties文件的路径，并读取其中的属性（扫描路径）；在init()方法中添加初始化内容:
@Override
public void init(ServletConfig config) throws ServletException {
//1.加载配置文件
doLoadConfig(config.getInitParameter("contextConfigLocation"));
//2.扫描相关类(解析配置)
doScanner(contextConfig.getProperty("scanPackage"));
//3.初始化扫描到的类，并且把他们加载到IOC容器中
doInstance();
//4.实现依赖注入（自动赋值）
doAutowired();
//5.初始化handlerMapping
initHandlerMapping();
System.out.println("my Spring init");
}1)doLoadConfig()方法,将配置文件读取到Pripeties 中
private void doLoadConfig(String contextConfigLocation) {
//反射加载过程有讲到过读取classPath下的配置文件方法
InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
try {
contextConfig.load(is);
} catch (IOException e) {
e.printStackTrace();
}finally {
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}2）doScanner()，递归扫描所有的Class文件
private void doScanner(String scanPackage) {
//得到一个url(将所有的“.“替换成”/“)
URL url = this.getClass().getClassLoader().getResource("/"+scanPackage.replaceAll("\\.","/"));
File classDir = new File(url.getFile());
for(File file :classDir.listFiles()){
if(file.isDirectory()){ //如果是文件夹
//递归
doScanner(scanPackage+"."+file.getName());
}else{
if(file.getName().endsWith(".class")){ //如果不是文件夹，是文件
String className = (scanPackage+"."+file.getName()).replace(".class","");
//获取到所有class文件的路径，存入一个list中
classNames.add(className);
}
}
}
}3）doInstance()方法，初始化相关的类，并将其放入Ioc容器中（一个map）ioc的key默认是类名首字母小写，为此还写了个lowerFirstCase(String beanName) 方法：
private void doInstance() {
//将扫描到的类进行反射
try {
if(classNames.isEmpty()){
return;
}
for(String className : classNames){
Class<?> clazz = Class.forName(className);
//将实例化后的对象保存进IOC容器；
if(clazz.isAnnotationPresent(DemoController.class)){
Object o = clazz.newInstance();
//类名首字母小写，建立一个lowerFirstCase方法(转换成char[] 数组操作 chars[0]+=32)
String beanName = lowerFirstCase(clazz.getSimpleName());
ioc.put(beanName,o);
}else if(clazz.isAnnotationPresent(DemoService.class)){
// service 注入的不是他本身，而是它的实现类
//1.默认类名首字母小写（Interface）
//2.自定义beanName;
DemoService demoService = clazz.getAnnotation(DemoService.class);
String beanName = demoService.value();
if("".equals(beanName)){
beanName = lowerFirstCase(clazz.getSimpleName());
}
Object o = clazz.newInstance();
ioc.put(beanName,o);
//3. 如果是接口的实现(impl)的话，用他的接口类型作为key
Class<?>[] interfaces = clazz.getInterfaces();
for(Class<?> i :interfaces){
//如果一个接口有多个实现类，会出现重复的情况
if(ioc.containsKey(i.getName())){
throw new Exception("The beanName is exists");
}
ioc.put(i.getName(),o);
}
}else{
continue;
}
}
}catch (Exception e){
e.printStackTrace();
}
}
private String lowerFirstCase(String simpleName) {
char[] chars = simpleName.toCharArray();
chars[0]+=32;
return String.valueOf(chars);
}
4)doAutowired()方法，为Ioc容器中类的属性赋值
private void doAutowired() {
if(ioc.isEmpty()){
return;
}
for(Map.Entry<String,Object> entry:ioc.entrySet()){
//获取所有属性(包括私有)
Field[] fields = entry.getValue().getClass().getDeclaredFields();
for(Field field :fields){
//只注入Autowired注解
if(!field.isAnnotationPresent(DemoAutowired.class)){continue;}
DemoAutowired demoAutowired = field.getAnnotation(DemoAutowired.class);
String beanName = demoAutowired.value().trim();
if("".equals(beanName)){//如果注解里的属性名是空的话，使用类名
beanName = field.getType().getName();
}
field.setAccessible(true);
try {
//使用反射为属性赋值
field.set(entry.getValue(),ioc.get(beanName));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}5）initHandlerMapping()方法，将访问时的url和DemoAction 的方法关联
private void initHandlerMapping() {
//找到方法路径
if(ioc.isEmpty()){return;}
for(Map.Entry<String,Object> entry : ioc.entrySet()){
Class<?> clazz = entry.getValue().getClass();
if(!clazz.isAnnotationPresent(DemoController.class)){
continue;
}
String baseUrl = "";
if(clazz.isAnnotationPresent(DemoRequestMapping.class)){
DemoRequestMapping demoRequestMapping = clazz.getAnnotation(DemoRequestMapping.class);
baseUrl = demoRequestMapping.value();
}
//这里不需要获取private的方法，Spring源码中也是这样的
Method[] methods = clazz.getMethods();
for(Method method:methods){
//只用requestMapping 的方法才需要映射
if(!method.isAnnotationPresent(DemoRequestMapping.class)){
continue;
}
DemoRequestMapping demoRequestMapping = method.getAnnotation(DemoRequestMapping.class);
//多个“/” 替换成一个“/”；
String url = ("/"+baseUrl+"/"+demoRequestMapping.value()).replaceAll("/+","/");
handlerMapping.put(url,method);
System.out.println("Mapped:"+url+","+method);
}
}
}3.运行阶段
运行时，用户发送的请求都会被DispatcherServlet 接受，统一调用dopost方法，因此在dopost()方法中添加doDispatch()方法
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//运行阶段，根据用户请求的url，进行调动
try {
doDispatch(req,resp);
}catch (Exception e){
e.printStackTrace();
resp.getWriter().write("500 Detail:"+ Arrays.toString(e.getStackTrace()));
}
}
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws IOException, InvocationTargetException, IllegalAccessException {
if(this.handlerMapping.isEmpty()){return;}
//绝对路径
String url = req.getRequestURI();
//绝对路径处理成相对路径
String contextPath = req.getContextPath();
url = url.replace(contextPath,"").replaceAll("/+","/");
if(!this.handlerMapping.containsKey(url)){
resp.getWriter().write("404 NOT FOUND");
return;
}
Method method =this.handlerMapping.get(url);
//反射调用
//1.方法所在类的实例（从IOC容器中拿）
//这里没有办法获得IOCmap中的key,只能通过方法所在类的类名首字母小写获得，与Spring的方法不同
String beanName = lowerFirstCase(method.getDeclaringClass().getSimpleName());
//浏览器参数
Map<String,String[]>params = new HashMap<String, String[]>();
params = req.getParameterMap();
method.invoke(ioc.get(beanName),new Object[]{req,resp,params.get("name")[0]});
}到此整个配置完成；在浏览器输入地址：
、
以下是DispatcherServlet的全部代码：
package com.wj.spring.mvcframework.servlet;
import com.wj.spring.mvcframework.annotation.DemoAutowired;
import com.wj.spring.mvcframework.annotation.DemoController;
import com.wj.spring.mvcframework.annotation.DemoRequestMapping;
import com.wj.spring.mvcframework.annotation.DemoService;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;
/**
* Created by 小美女 on 2018/12/9.
*/
public class DispatcherServlet extends HttpServlet{
private Properties contextConfig = new Properties();
private List<String> classNames = new ArrayList<String>();
//ioc容器
Map<String,Object> ioc = new HashMap<String, Object>();
//类里面的方法集合
Map<String,Method> handlerMapping = new HashMap<String, Method>();
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//运行阶段，根据用户请求的url，进行调动
try {
doDispatch(req,resp);
}catch (Exception e){
e.printStackTrace();
resp.getWriter().write("500 Detail:"+ Arrays.toString(e.getStackTrace()));
}
}
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws IOException, InvocationTargetException, IllegalAccessException {
if(this.handlerMapping.isEmpty()){return;}
//绝对路径
String url = req.getRequestURI();
//绝对路径处理成相对路径
String contextPath = req.getContextPath();
url = url.replace(contextPath,"").replaceAll("/+","/");
if(!this.handlerMapping.containsKey(url)){
resp.getWriter().write("404 NOT FOUND");
return;
}
Method method =this.handlerMapping.get(url);
//反射调用
//1.方法所在类的实例（从IOC容器中拿）
//这里没有办法获得IOCmap中的key,只能通过方法所在类的类名首字母小写获得，与Spring的方法不同
String beanName = lowerFirstCase(method.getDeclaringClass().getSimpleName());
//浏览器参数
Map<String,String[]>params = new HashMap<String, String[]>();
params = req.getParameterMap();
method.invoke(ioc.get(beanName),new Object[]{req,resp,params.get("name")[0]});
}
@Override
public void init(ServletConfig config) throws ServletException {
//1.加载配置文件
doLoadConfig(config.getInitParameter("contextConfigLocation"));
//2.扫描相关类(解析配置)
doScanner(contextConfig.getProperty("scanPackage"));
//3.初始化扫描到的类，并且把他们加载到IOC容器中
doInstance();
//4.实现依赖注入（自动赋值）
doAutowired();
//5.初始化handlerMapping
initHandlerMapping();
System.out.println("my Spring init");
}
private void initHandlerMapping() {
//找到方法路径
if(ioc.isEmpty()){return;}
for(Map.Entry<String,Object> entry : ioc.entrySet()){
Class<?> clazz = entry.getValue().getClass();
if(!clazz.isAnnotationPresent(DemoController.class)){
continue;
}
String baseUrl = "";
if(clazz.isAnnotationPresent(DemoRequestMapping.class)){
DemoRequestMapping demoRequestMapping = clazz.getAnnotation(DemoRequestMapping.class);
baseUrl = demoRequestMapping.value();
}
//这里不需要获取private的方法，Spring源码中也是这样的
Method[] methods = clazz.getMethods();
for(Method method:methods){
//只用requestMapping 的方法才需要映射
if(!method.isAnnotationPresent(DemoRequestMapping.class)){
continue;
}
DemoRequestMapping demoRequestMapping = method.getAnnotation(DemoRequestMapping.class);
//多个“/” 替换成一个“/”；
String url = ("/"+baseUrl+"/"+demoRequestMapping.value()).replaceAll("/+","/");
handlerMapping.put(url,method);
System.out.println("Mapped:"+url+","+method);
}
}
}
private void doAutowired() {
if(ioc.isEmpty()){
return;
}
for(Map.Entry<String,Object> entry:ioc.entrySet()){
//获取所有属性(包括私有)
Field[] fields = entry.getValue().getClass().getDeclaredFields();
for(Field field :fields){
//只注入Autowired注解
if(!field.isAnnotationPresent(DemoAutowired.class)){continue;}
DemoAutowired demoAutowired = field.getAnnotation(DemoAutowired.class);
String beanName = demoAutowired.value().trim();
if("".equals(beanName)){//如果注解里的属性名是空的话，使用类名
beanName = field.getType().getName();
}
field.setAccessible(true);
try {
//使用反射为属性赋值
field.set(entry.getValue(),ioc.get(beanName));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
private void doInstance() {
//将扫描到的类进行反射
try {
if(classNames.isEmpty()){
return;
}
for(String className : classNames){
Class<?> clazz = Class.forName(className);
//将实例化后的对象保存进IOC容器；
if(clazz.isAnnotationPresent(DemoController.class)){
Object o = clazz.newInstance();
//类名首字母小写，建立一个lowerFirstCase方法(转换成char[] 数组操作 chars[0]+=32)
String beanName = lowerFirstCase(clazz.getSimpleName());
ioc.put(beanName,o);
}else if(clazz.isAnnotationPresent(DemoService.class)){
// service 注入的不是他本身，而是它的实现类
//1.默认类名首字母小写（Interface）
//2.自定义beanName;
DemoService demoService = clazz.getAnnotation(DemoService.class);
String beanName = demoService.value();
if("".equals(beanName)){
beanName = lowerFirstCase(clazz.getSimpleName());
}
Object o = clazz.newInstance();
ioc.put(beanName,o);
//3. 如果是接口的实现(impl)的话，用他的接口类型作为key
Class<?>[] interfaces = clazz.getInterfaces();
for(Class<?> i :interfaces){
//如果一个接口有多个实现类，会出现重复的情况
if(ioc.containsKey(i.getName())){
throw new Exception("The beanName is exists");
}
ioc.put(i.getName(),o);
}
}else{
continue;
}
}
}catch (Exception e){
e.printStackTrace();
}
}
private String lowerFirstCase(String simpleName) {
char[] chars = simpleName.toCharArray();
chars[0]+=32;
return String.valueOf(chars);
}
private void doScanner(String scanPackage) {
//得到一个url(将所有的“.“替换成”/“)
URL url = this.getClass().getClassLoader().getResource("/"+scanPackage.replaceAll("\\.","/"));
File classDir = new File(url.getFile());
for(File file :classDir.listFiles()){
if(file.isDirectory()){ //如果是文件夹
//递归
doScanner(scanPackage+"."+file.getName());
}else{
if(file.getName().endsWith(".class")){ //如果不是文件夹，是文件
String className = (scanPackage+"."+file.getName()).replace(".class","");
//获取到所有class文件的路径，存入一个list中
classNames.add(className);
}
}
}
}
private void doLoadConfig(String contextConfigLocation) {
//反射加载过程有讲到过读取classPath下的配置文件方法
InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
try {
contextConfig.load(is);
} catch (IOException e) {
e.printStackTrace();
}finally {
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
7249
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
