/**
* 控制層注解
* @Controller
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {

String value() default "";
}

/**
* 請求路徑注解
* @RequestMapping
*/
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {

String value() default "";
}

/**
* 參數(shù)注解
* @RequestParam
*/
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {

String value() default "";
}

/**
* 服務(wù)層注解
* @Controller
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {

String value() default "";
}

/**
* 自動裝載注解
* @Autowrited
*/
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

String value() default "";
}

* servlet跳轉(zhuǎn)層
*/
@WebServlet(name = "DispatcherServlet",urlPatterns = "/*", loadOnStartup = 1, initParams = {@WebInitParam(name="scanPackage", value="com.example.mvc")})
public class DispatcherServlet extends HttpServlet {

private static final long serialVersionUID = 1L;

private static final Logger logger = LoggerFactory.getLogger(DispatcherServlet.class);

/**請求方法映射容器*/
private static List<RequestHandler> handlerMapping = new ArrayList<>();

/**
* 服務(wù)啟動的時候，進(jìn)行初始化，流程如下：
* 1、掃描指定包下所有的類
* 2、通過反射將類實例，放入ioc容器
* 3、通過Autowired注解，實現(xiàn)自動依賴注入，也就是set類中的屬性
* 4、通過RequestMapping注解，獲取需要映射的所有方法，然后將類信息存放到容器中
* @param config
* @throws ServletException
*/
@Override
public void init(ServletConfig config) throws ServletException {
try {
//1、掃描指定包下所有的類
String scanPackage = config.getInitParameter("scanPackage");
//1、掃描指定包下所有的類
List<String> classNames = doScan(scanPackage);
//2、初始化所有類實例，放入ioc容器，也就是map對象中
Map<String, Object> iocMap = doInstance(classNames);
//3、實現(xiàn)自動依賴注入
doAutowired(iocMap);
//5、初始化方法mapping
initHandleMapping(iocMap);
} catch (Exception e) {
logger.error("dispatcher-servlet類初始化失敗!",e);
throw new ServletException(e.getMessage());
}
}


/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
doPost(request, response);
}

/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
//跳轉(zhuǎn)
doDispatch(request, response);
}

/**
* 掃描指定包下的類文件
* @param packageName
* @return
*/
private List<String> doScan(String packageName){
if(StringUtils.isBlank(packageName)){
throw new RuntimeException("mvc配置文件中指定掃描包名為空!");
}
return PackageHelper.getClassName(packageName);
}

private Map<String, Object> doInstance(List<String> classNames) {
Map<String, Object> iocMap = new HashMap<>();
if(!CollectionUtils.isNotEmpty(classNames)){
throw new RuntimeException("獲取的類為空!");
}
for (String className : classNames) {
try {
//通過反射機(jī)制構(gòu)造對象
Class<?> clazz = Class.forName(className);
if(clazz.isAnnotationPresent(Controller.class)){
//將類名第一個字母小寫
String baneName = firstLowerCase(clazz.getSimpleName());
iocMap.put(baneName, clazz.newInstance());
}else if(clazz.isAnnotationPresent(Service.class)){
//服務(wù)層注解判斷
Service service = clazz.getAnnotation(Service.class);
String beanName = service.value();
//如果該注解上沒有自定義類名，則默認(rèn)首字母小寫
if(StringUtils.isBlank(beanName)){
beanName = clazz.getName();
}
Object instance = clazz.newInstance();
iocMap.put(beanName, instance);
//如果注入的是接口，可以巧妙的用接口的類型作為key
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> clazzInterface : interfaces) {
iocMap.put(clazzInterface.getName(), instance);
}
}
} catch (Exception e) {
logger.error("初始化mvc-ioc容器失敗!",e);
throw new RuntimeException("初始化mvc-ioc容器失敗!");
}
}
return iocMap;
}

/**
* 實現(xiàn)自動依賴注入
* @throws Exception
*/
private void doAutowired(Map<String, Object> iocMap) {
if(!MapUtils.isNotEmpty(iocMap)){
throw new RuntimeException("初始化實現(xiàn)自動依賴失敗，ioc為空!");
}
for(Map.Entry<String, Object> entry : iocMap.entrySet()){
//獲取對象下所有的屬性
Field[] fields = entry.getValue().getClass().getDeclaredFields();
for (Field field : fields) {
//判斷字段上有沒有@Autowried注解，有的話才注入
if(field.isAnnotationPresent(Autowired.class)){
try {
Autowired autowired = field.getAnnotation(Autowired.class);
//獲取注解上有沒有自定義值
String beanName = autowired.value().trim();
if(StringUtils.isBlank(beanName)){
beanName = field.getType().getName();
}
//如果想要訪問到私有的屬性，我們要強(qiáng)制授權(quán)
field.setAccessible(true);
field.set(entry.getValue(), iocMap.get(beanName));
} catch (Exception e) {
logger.error("初始化實現(xiàn)自動依賴注入失敗!",e);
throw new RuntimeException("初始化實現(xiàn)自動依賴注入失敗");
}
}
}
}
}

/**
* 初始化方法mapping
*/
private void initHandleMapping(Map<String, Object> iocMap){
if(!MapUtils.isNotEmpty(iocMap)){
throw new RuntimeException("初始化實現(xiàn)自動依賴失敗，ioc為空");
}
for(Map.Entry<String, Object> entry:iocMap.entrySet()){
Class<?> clazz = entry.getValue().getClass();
//判斷是否是controller層
if(!clazz.isAnnotationPresent(Controller.class)){
continue;
}
String baseUrl = null;
//判斷類有沒有requestMapping注解
if(clazz.isAnnotationPresent(RequestMapping.class)){
RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
baseUrl= requestMapping.value();
}
Method[] methods = clazz.getMethods();
for (Method method : methods) {
//判斷方法上有沒有requestMapping
if(!method.isAnnotationPresent(RequestMapping.class)){
continue;
}
RequestMapping requestMethodMapping = method.getAnnotation(RequestMapping.class);
//"/+",表示將多個"/"轉(zhuǎn)換成"/"
String regex = (baseUrl + requestMethodMapping.value()).replaceAll("/+", "/");
Pattern pattern = Pattern.compile(regex);
handlerMapping.add(new RequestHandler(pattern, entry.getValue(), method));
}
}
}

/**
* servlet請求跳轉(zhuǎn)
* @param request
* @param response
* @throws IOException
*/
private void doDispatch(HttpServletRequest request, HttpServletResponse response) throws IOException {
try {
request.setCharacterEncoding("UTF-8");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Pragma", "no-cache");
response.setDateHeader("Expires", -1);
response.setContentType("text/html");
response.setHeader("content-type", "text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
RequestHandler handle = getHandleMapping(request);
if(Objects.isNull(handle)){
//異常請求地址
logger.warn("異常請求地址!地址:" + request.getRequestURI());
response.getWriter().append("error request url");
return;
}
//獲取參數(shù)列表
Object[] paramValues = RequestParamHelper.buildRequestParam(handle, request, response);
Object result = handle.getMethod().invoke(handle.getController(), paramValues);
if(result != null){
PrintWriter out = response.getWriter();
out.println(result);
out.flush();
out.close();
}
} catch (Exception e) {
logger.error("接口請求失敗!",e);
PrintWriter out = response.getWriter();
out.println("請求異常,請稍后再試");
out.flush();
out.close();
}
}

/**
* 將類名第一個字母小寫
* @param clazzName
* @return
*/
private String firstLowerCase(String clazzName){
char[] chars = clazzName.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}


/**
* 獲取用戶請求方法名
* 與handlerMapping中的路徑名進(jìn)行匹配
* @param request
* @return
*/
private RequestHandler getHandleMapping(HttpServletRequest request){
if(CollectionUtils.isNotEmpty(handlerMapping)){
//獲取用戶請求路徑
String url = request.getRequestURI();
String contextPath = request.getContextPath();
String serviceUrl = url.replace(contextPath, "").replaceAll("/+", "/");
for (RequestHandler handle : handlerMapping) {
//正則匹配請求方法名
Matcher matcher = handle.getPattern().matcher(serviceUrl);
if(matcher.matches()){
return handle;
}
}
}
return null;
}
}

@Controller
@RequestMapping("/user")
public class LoginController {

@Autowired
private UserService userService;

/**
* 用戶登錄
* @param request
* @param response
* @param userName
* @param userPwd
* @return
*/
@RequestMapping("/login")
public String login(HttpServletRequest request, HttpServletResponse response,
@RequestParam("userName") String userName,
@RequestParam("userPwd") String userPwd){
boolean result = userService.login(userName, userPwd);
if(result){
return "登錄成功！";
} else {
return "登錄失敗！";
}
}
}

public interface UserService {

/**
* 登錄
* @param userName
* @param userPwd
* @return
*/
boolean login(String userName, String userPwd);
}

@Service
public class UserServiceImpl implements UserService {

@Override
public boolean login(String userName, String userPwd) {
if("zhangsan".equals(userName) && "123456".equals(userPwd)){
return true;
} else {
return false;
}
}
}