java 如何获取app_token

转载

小咪咪 2024-10-30 09:47:14

文章标签 java 如何获取app_token java spring System xml 文章分类 Java 后端开发

springmvc:接收浏览器发来的请求，并作出响应

MVC(Model模型、View视图、Control控制层)，将软件进行分层达到松耦合的效果。

通用的软件编程思想, 在MVC设计模式中认为, 任何软件都可以分三层：控制层（Controller）、数据处理模型（Model）、负责展示数据的视图（View）。

mvc工作原理

java 如何获取app_token_java 如何获取app_token

前端发送请求给前端控制器，前端控制器（DispatchServlet）根据请求调用相应的处理器映射器（HandllerMapping），处理映射器找到具体的处理器（可以根据xml配置，注解进行查找），生成处理器对象以及处理器拦截器（有则生成）一并返回给前端控制器,前端控制器调用处理器适配器（HandllerAdapter),处理器适配器经过适配调用具体的处理器（controller），controller执行完毕返回ModelAndVie给处理器适配器，处理器适配器将ModelAncView返回给前端控制器，前端控制器将其传给视图解析器（VIewReslove）,视图解析器解析完返回具体的视图（View）给前端控制器，前端控制器根据view进行视图渲染（即将模型数据填充至视图中）然后响应给客户

入门操作：前端发送请求localhost：8080/Stu/jack/2

后端接收数据并再控制台打印

1.创建Stu对象接收前端传过来的参数

package com.example.ttt.collection.pojo;

import lombok.Data;

@Data 

public class Stu {
    String name;
    String age;
}

2.controller代码

package com.example.ttt.collection;

import com.example.ttt.collection.pojo.Stu;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;



@RestController
public class JDBCtest {

//方法一
   @RequestMapping("/c/{name}/{age}")
    public void  save(Stu stu) {

       System.out.println(stu);

    }


}


//方法2

@RestController
public class JDBCtest {
   @RequestMapping("/c/{name}/{age}")
    public void  save(@PathVariable String name,
                      @PathVariable Integer age) {

       System.out.println(name+age);
}

请求方式有8种，常用的有get和post：

get:向特定资源发送请求并返回实体，有固定的写法，且长度有限

localhost:8080/car?color=red&size=1234

post:一般用作表单数据提交，数据被包含在请求体中，post可能会导致新的资源的建立或已有资源的修改

RestFul风格，用来简化Get请求：

1、需要使用注解@PathVariable来获取请求路径中的参数值,@PathVariable用来绑定值，也可以再后端用响应的对象来接

2、通过{.....}获取路径中传递来的值

3、以前GET的访问方式即将被简化成:localhost:8080/car/red/1234

SpringMVC常用的注解

@RequestMapping 请求后的映射路径

@PathVariable 标识接收单个参数

@ResponseBody 返回对象利用jackson工具类转换为json字符串

@RequestParam 参数名和请求参数名称不同时使用，可以设置默认值

@controller标识是一个Controller，Spring包扫描创建实例

@RestController相当于@responseBody和@Controller

Maven四大特征：

仓库：分为远程，镜像，本地仓库三种

依赖：每个核心jar包形成一个依赖，maven底层对它相关的jar包进行自动导入

坐标：jar包定位方式：groupId：指定jar包的组id artfactId:指定jar包的项目id version：指定jar包的版本

命令：Maven借鉴前辈定义了一套生命周期，共有3个生命周期：clean、default、site，每个生命周期包含多个阶段phase ，每个周期中运行一个命令时，在这个周期里的其他在该命令之前的phase步骤都会执行，这意味着一下执行了很多的命令，也称为一键部署，而这过程都是全自动的，以前的开发者每一步都是自己去做的。

Spring

spring框架主要用来管理Bean

模块说明核心容器Spring Core 核心容器提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式，将应用程序的配置和依赖性规范与实际的应用程序代码分开。Spring上下文Spring Context Spring上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。Spring AOP 通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。可以很容易地使 Spring框架管理的任何对象支持AOP。Spring AOP模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。Spring DAO JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构Spring ORM Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring MVC框架 MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。Spring Web Web上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以Spring 框架支持与 Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring框架两大核心Ioc和DI

IOC（Inversion of Control），控制反转。

就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。

DI（Dependency Injection）依赖注入。

相对于IoC而言，依赖注入(DI)更加准确地描述了IoC的设计理念。所谓依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。

Ioc控制反转方式：

1.新建xml文件，具体位置如下图

2.将要注入的对象写在配置文件中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean class="com.example.ttt.pojo.Stu" id="stu"></bean>
//class记录的是类的全路径  id是类的名字，首字母要小写


</beans>

3.从Spring容器中获取Bean

package com.example.ttt.pojo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Ioctest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext spring=new ClassPathXmlApplicationContext("springconfig.xml");//参数为配置文件名

        Object o=spring.getBean("stu");//创建时类名首字母小写
      Object o2=spring.getBean("stu");
    Stu stu= (Stu) spring.getBean("stu");
    stu.getAge();

        System.out.println(o==o2);//结果为true
    }

}

ioc有三个核心：Beanfactory 反射 DI

BeanFactory利用反射实现对象的创建，Di实现对对象的管理

DI可以理解为ioc的另一种说法

DI例子：

//准备测试类
package com.example.ttt.pojo;

import lombok.Data;
import org.springframework.stereotype.Component;

@Component
@Data
public class Dept {


    String name="jack";


}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">



    <context:component-scan base-package="com.example.ttt.pojo"/>
//添加配置文件，文件名具体到包，标识这个包下所有的添加了@Compent类都将交给Spring管理


</beans>

package com.example.ttt.pojo;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@Data
public class NewDept {
    String name="lu";

    @Autowired//添加依赖
    Dept dept;

public void m(){

    System.out.println(dept.getName());
}
}

//测试

package com.example.ttt.collection;


import com.example.ttt.pojo.Dept;
import com.example.ttt.pojo.NewDept;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {


    public static void main(String[] args) {


        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("appliction.xml");
        Dept d = (Dept) context.getBean("dept");
      NewDept n = (NewDept) context.getBean("newDept");
        System.out.println(d.getName());
        System.out.println(n.getName());
    System.out.println(d==n.m());//结果为true,说明对象是同一个，@Autowried自动注入了Bean对象
    }


    }

aop应用

环绕通知

package com.example.ttt.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component//提供扫描路径
@Aspect//定义切面
public class AspectTest {
//切点表达式 *代表一个 ..代表多个    第一个*代表返回值  后一个*代表方法名，前面是全路径  （）代表参数列表 

    @Pointcut("execution(* com.example.ttt.collection.Test.*())")
    public void pointcut(){};//固定写法

    @Around("pointcut()")//环绕通知
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {

long star=System.currentTimeMillis();
Object o=joinPoint.proceed();//执行业务方法并返回结果
long end =System.currentTimeMillis();

String methondName=joinPoint.getTarget().getClass().getName()+//获取类名
        "  "+joinPoint.getSignature().getName();//获取方法名

        System.out.println(methondName+"耗时"+(end-star));
return o;//执行完方法的返回值

    }






}

目标方法

package com.example.ttt.collection;


import com.example.ttt.pojo.Dept;
import com.example.ttt.pojo.NewDept;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Test {


@RequestMapping("/a")
    public void m(){//添加环绕通知的位置


    ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("appliction.xml");
    Dept d = (Dept) context.getBean("dept");
    NewDept n = (NewDept) context.getBean("newDept");
    System.out.println(d.getName());
    System.out.println(n.getName());
    System.out.println(d==n.m());
}

    }


/
执行结果
jack
lu
true
com.example.ttt.collection.Test  m耗时169