SSM自我总结

最新推荐文章于 2024-07-11 14:56:13 发布

&&月弥

最新推荐文章于 2024-07-11 14:56:13 发布

阅读量201

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/qq_57714322/article/details/130047009

版权

SpringMVC

一:工作原理

1，用户通过浏览器向服务器发送请求，请求会被Spring MVC的前端控制器（DispatcherServlet)拦截。
2，DispatcherServleet拦截请求后，会调用处理器映射器（HandlerMapping）。
3，HandlerMapping会根据请求的URL找到具体的处理器，生成处理器对象及处理器拦截器（有则生成）一并返回给      DispatcherServlet.
4,DispatcherServlet会通过返回信息选择合适的处理器适配器（HandlerAdapter）。
5，HandlerAdapter会调用并执行处理器（Handler），处理器指的是程序中写的Controller类，也称为后端控制器。
6，Controller执行完成后，会返回一个ModelAndView对象，该对象中包含视图名或者包含模型和视图名。
7,HandlerAdapter将ModelAndView对象返回给DispatcherServlet。
8，DispatcherServlet请求视图解析器（ViewResolver)根据逻辑视图名解析真正的视图。
9，ViewResolver解析后，会向DispatcherServlet返回具体的视图（View）对象。
10，DispatcherServlet对View进行渲染（即将模型数据填充到视图中）。
11，DispatcherServlet向用户响应结果。

二：Spring MVC的优点

1,Spring MVC是Spring框架中后续产品，可以方便的使用Spring框架所提供的其他功能。
2，使用简单，可以很容易设计出干净简洁的Web层。
3，支持各种请求资源的映射策略。
4，有非常灵活的数据验证，格式化和数据绑定机制，能适用任何对象进行数据绑定，不必实现特定框架的API。
5，支持国际化，可以根据用户的区域显示多国语言。
6，支持多种视图，jsp,velocity,FreeMarker
7,灵活性强，易扩展。

三:pom.xml,resources和web的配置信息

1:pom.xml

<?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>org.example</groupId>
    <artifactId>springmvc01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <dependencies>
        <!--Spring 核心类-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Spring MVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--JSP-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
             <!-- Jackson核心转换包依赖-->
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.11.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.12.4</version>
        </dependency>
    </dependencies>
</project>

2:applicationContext.xml

<?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.itheima" use-default-filters="true">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

3:spring-mvc.xml

<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">
      <context:component-scan base-package="com.itheima.Controller"/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="viewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <mvc:annotation-driven/>
    <mvc:resources mapping="/js/**" location="/js/"/>
</beans>

4：web.xml(spring 和spring mvc 分开)

<?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_4_0.xsd"
         version="4.0">
    <servlet>  //这是引入Spring MVC的配置信息
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

四：注解

1，@Controller：用于将java类变成spring mvc的处理器类，用于类上面
2，@RequestMapping :用于建立请求URL和Handler类之间的映射关系，可以标注在方法上和类上 有多个参数如下
name:为映射地址定义别名
value：用于请求的URL
method:用于指定该方法用于那种类型的请求方式
params:请求中参数的值必须包含那些参数的值

@GetMapping:匹配GET方式的请求
@PostMapping:匹配Post方式的请求

3，@RequestParam: 定义参数的别名 完成请求的参数名称和处理器的形参名称不一致时的数据绑定，该注解用于方法参数列表中
value:name属性的别名，参数的名称
name:绑定的请求参数名称
required：用于指定参数是否必须
defaultValue：默认值,
4，@RequestBody:结合Jackson提供的JSON格式转换器，书写咋方法的形参前，
@ResponseBody 注解，表示这个方法到此为止，不用再去查找相关视图，就是返回一个正常类型
5,@ControllerAdvice: 异常处理注解，用在类上面，可以增强Controller,配合@ExceptionHandler注解一块使用
后者用于方法中，@ExceptionHandler（自定义异常类.class）

五：拦截器

一种动态拦截Controller方法调用的对象，可以再指定的方法调用前后者调用后执行预定设计的代码

两种实现方式：

1实现HandlerInterceptor接口定义拦截器

2 继承HandlerInterceptorAdapter定义拦截器

MyBatis

一：工作原理

1,读取核心配置文件mybatis-config.xml
2,加载映射文件Mapper.xml,SQL映射文件，每个映射文件对应数据库的一张表
3,构造会话工厂 SqlSessionFactory
4,创建会话对象 SQLSession
5，创建执行器Executor 执行器会根据SQLSession传入的参数动态生成要执行的SQL语句
6，封装映射（SQL）信息  执行器调用MapperStatement
7,操作数据库
8，输出结果映射 通过MapperStatement对象将输入的参数映射到java对象中

解释说明：ORM框架是指一种解决面向对象和关系型数据库中数据类型不匹配的技术

二：三个核心对象及核心配置

SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBulider().build("配置文件");
SqlSession sqlSession=sqlSessionFactory.openSession();

工具类：
    public class MybatisUtils {
        private static SqlSessionFactory sqlSessionFactory=null;
        static {
            try{
                Reader reader= Resources.getResourceAsReader("mybatis-config.xml");
                sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
        public  static SqlSession getSession(){
            return  sqlSessionFactory.openSession();
        }

2：核心配置文件（mybatis-config.xml)

<configuration>  根元素
   <properties>   配置属性，加载外部文件的配置信息
   <environments>  配置环境  如开发环境，运行环境，测试环境。。。
       <environment>  
          <transactionManager> 配置运行时的事务管理器
           <dataScource>       配置运行时的数据源
    <mappers>      引入mybatis映射文件  字标签为mapper
    1使用类路径         <mapper resource="mapper/PersonMapper.xml"/>
    2使用本地文件路径    <mapper url="file:///D:/com/itheima/mapper/PersonMapper.xml"/>
    3使用接口类          <mapper class="dao.ProductMapper"/>
    4使用包名            <package name="com.itheima.mapper"/>
        
  db.properties配置文件信息：
        
     mysql.driver=com.mysql.cj.jdbc.Driver
     mysql.url=jdbc:mysql://localhost:3306/mybatis?       useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
    characterEncoding=utf8&useUnicode=true&useSSL=false
    mysql.username=root
    mysql.password=admin   
        
   mybatis-config.xml如下：
        
   <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--    核心配置文件信息-->
    <properties resource="db.properties"></properties>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper class="dao.WorkerMapper"/>
        <mapper class="dao.IdCardMapper"/>
        <mapper class="dao.PersonMapper"/>
        <mapper class="dao.OrdersMapper"/>
        <mapper class="dao.UsersMapper"/>
        <mapper class="dao.ProductMapper"/>
    </mappers>
</configuration>

3:注解（xml的方式太过麻烦）

单表查询
1 @Select 

@Select("select * from tb_person where id=#{id}")

2 @Insert 
代码如下：
@Insert("insert into tb_worker(name,age,sex,worker_id)"
            +"values(#{name},#{age},#{sex},#{worker_id})")
    int insertWorker(Worker worker);
    
3 @Update

@Update("update tb_worker set name=#{name},age=#{age} where id=#{id}")
    int updateWorker(Worker worker);
    
4 @Delete

@Delete("delete from tb_worker where id=#{id}")
    int deleteWorker(int id);
    
 5 @Param
 
 @Select("select * from tb_worker where  id = #{param01}")
    Worker selectWorker(@Param("param01") int id);
    
  多表联查
  //一对一查询数据用One
    @Select("select * from tb_person where id=#{id}")
    @Results({@Result(column ="card_id",property = "card",
    one=@One(select = "dao.IdCardMapper.selectIdCardById"))})
    Person selectPersonByid(int id);
    property用于关联的实体类属性 column用于关联数据库表中字段，one用于那种关联关系
    
   //一对多查询数据
    @Select("select  * from tb_orders where user_id=#{id}")
    @Results({@Result(id = true, column = "id", property = "id"),
    @Result(column = "number",property = "number")
    })
    List<Orders> selectOrdersByUserId(int user_id);
    
    @Select("select * from tb_user where id=#{id}")
    @Results({
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "username",property = "username"),
            @Result(column = "address",property = "address"),
            @Result(column = "id",property = "ordersList",
            many = @Many(select = "dao.OrdersMapper.selectOrdersByUserId"))})
    Users selectUserById(int id);
    
    //多对多查询数据 根据订单id查询数据
    @Select("select * from tb_product where id in (select product_id from" +
            " tb_ordersitem where orders_id=#{id})")
    List<Product> selectProductByOrdersId(int orders_id);


    //多对多查询数据
    @Select("select  * from tb_orders where user_id=#{id}")
    @Results({
            @Result(id = true,column = "id",property = "id"),
            @Result(column ="number",property = "number"),
            @Result(column = "id",property = "productList",
            many  =@Many(select = "dao.ProductMapper.selectProductByOrdersId")
            )})
    Orders selectOrdersById(int id);

4：mybatis-config.xml

<?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>org.example</groupId>
    <artifactId>mybatis_02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

Spring

一：优点

（1）非侵入式设计 允许应用进程自由选择和组装Spring框架中得到各种功能模块
    、降低耦合性，方便开发、支持AOP编程、支持声明式事务、方便程序的测试、方便集成各种优秀框架和降低Java EE API的使用难度。
（2）控制反转（Inversion of Control，缩写为IoC）是面向对象编程中的一个设计原则，用来降低程序代码之间的耦合度。控制反转就是指在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转。
依赖注入（Dependency Inject，缩写DI）就是由IoC容器在运行期间动态地将某种依赖资源注入对象之中。例如，将对象B注入（赋值）给对象A的成员变量。依赖注入的基本思想是：明确地定义组件接口，独立开发各个组件，然后根据组件的依赖关系组装运行。

二：常用属性：

<constructor-arg>  为构造函数赋值（依赖注入）[name value]
<property>         为setter方法赋值
BeanFactory接口，最经典的java工厂模式  getBean()方法
ApplicationContext接口:  ClassPathXmlApplictationContext
<bean 
id=""   唯一标识
name=""  名称
class=""  具体实现类
scope=""  Bean作用域   singliton 单例   prototpye 每次创建新的Bean实例
factory-method="" 用于指定所定义的静态方法
autowrite="byName" 根据bean元素中的id值自动装配（注入依赖）
>
<context:component-scan base-package="com.itheima"/>  打开扫描器
依赖注入常用注解
@Component:指定一个Bean，可以作用于任何层次
@Controller：作用域控制层
@Service： 作用域业务层
@Repository:指定一个数据访问层中的Bean
@Scope：    作用域
@Value：    注入值
@Autowired: 指定要自动装配的对象
@Resource： 要注入的对象   使用方式为： @Resource(name="")
@Qualifier: 自动装配对象的名称 和Autowired连用
@PostContruct:指定bean实例完成初始化之后要执行的方法
@PreDestroy: 销毁前要调用的方法

Aop 面向切面编程
       <!--    基于XMl的AOP-->
    <bean name="userDao" class="com.itheima03.UserDaoImpl"/>
    <bean name="xmlAdvice" class="com.itheima03.XmlAdvice"/>
<!--    配置Spring aop-->
    <aop:config>
<!--        配入切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.itheima03.UserDaoImpl.*(..))"/>
<!--       配置切面 -->
        <aop:aspect ref="xmlAdvice">
            <!-- 指定前置通知 -->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <!-- 指定返回通知 -->
            <aop:after-returning method="afterReturning"
                                 pointcut-ref="pointcut"/>
            <!-- 指定环绕方式 -->
            <aop:around method="around" pointcut-ref="pointcut"/>
            <!-- 指定异常通知 -->
            <aop:after-throwing method="afterException"
                                pointcut-ref="pointcut"/>
            <!-- 指定后置通知 -->
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
    
    <!--基于注解的AOP实现-->
    <!--    开启aspectj-autoproxy自动代理支持-->
     <aop:aspectj-autoproxy/>
   @Aspect: 配置切面
   @Pointcut： 配置切入点
    @Before：
    @After：
    @Around：
    @AfterReturning: 配置返回通知
    @AfterThrowing: 配置异常通知
    
    
    
   <!--JdbcTemplate-->
        <!-- 1配置数据源 -->
    <bean id="dataSource" class=
            "org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!--数据库驱动 -->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <!--连接数据库的url -->
     <property name="url" value=" jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&amp;serverTimezone=Asia/Shanghai&amp;useSSL=false"/>
        <!--连接数据库的用户名 -->
        <property name="username" value="root" />
        <!--连接数据库的密码 -->
        <property name="password" value="admin" />
    </bean>
    <!-- 2配置JDBC模板 -->
    <bean id="jdbcTemplate"
          class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 默认必须使用数据源 -->
        <property name="dataSource" ref="dataSource" />
    </bean>
    <bean id="accountDao" class="com.itheima.AccountDaoImpl">
<!--        将jdbcTemplate注入到accountDao实例中-->
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
    
    <!--    基于XML的方式实现声明式事物 -->
      <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--    事物管理器，依赖于数据源-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT" read-only="false"/>
        </tx:attributes>
    </tx:advice>
<!--    编写AOp 让spring自动为目标生成代理，需要用到AspectJ的表达式-->
    <aop:config >
<!--        切入点-->
        <aop:pointcut id="txPointCut" expression="execution(* com.itheima.*.*(..))"/>
<!--             切面-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
<!--    注册事务器驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    查询数据
     return this.jdbcTemplate.queryForObject(sql,rowMapper,id);
    
      String sql="select * from account";
        //创建一个新的BeanPropertyRowMapper对象
        RowMapper<Account> rowMapper=new BeanPropertyRowMapper<Account>(Account.class);
        return this.jdbcTemplate.query(sql,rowMapper);
   增删改方法
    String sql="update account set username=?,balance=? where id=?";
        Object[] objects=new Object[]{
                account.getUsername(),
                account.getBalance(),
                account.getId(),
        };
        int num=this.jdbcTemplate.update(sql,objects);
        return num;