Spring学习笔记

于 2021-08-23 21:49:27 发布
阅读量211 收藏 1
点赞数
分类专栏： Spring 文章标签： java spring maven intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nihaoa_1898/article/details/119463903
版权

spring实战（仅仅是本人的学习笔记，可能会有错误，大家见谅）

简介

1.spring是什么？

在这里插入图片描述
2. spring优势？
在这里插入图片描述
3. spring体系结构
在这里插入图片描述

Spring快速入门

开发步骤

  1. 导入坐标
  2. 创建bean
  3. 创建applicationContext.xml
  4. 在配置文件中进行配置
  5. 创建ApplicationContext对象getBean

Spring配置文件的配置

用于配置对象交由Spring来创建
默认情况下它调用的类中的无参构造函数，如果没有无参构造函数则不能创建成功

基本属性：
id：唯一标识
class：Bean的全限定名称

Bean标签范围配置
scope：值对象的作用范围

取值范围：
singleton：默认的，单例的
prototype：多里的
request：web项目中，Spring创建一个Bean对象，将对象存入request对象
session： 将对象存入session域中
global session：Web项目中，应用在portlrt环境中，如果没有portlet环境那么globalSession 相当于session

在这里插入图片描述
Bean生命周期设置
在这里插入图片描述
Bean实例化的三种方式

  1. 无参构造
  2. 工厂静态方法
  3. 工厂实例化方法实例化

依赖注入
在这里插入图片描述
如何将UserDao注入到UserServce?
Set方法

例如：在这里插入图片描述
简单方式：p命名空间
在这里插入图片描述

构造方法
例如：
在这里插入图片描述
bean容器可以注入集合，对象和普通的值

 <bean id="userDao" class="com.itheima.Impl.UserDaoImpl">
        <property name="list">
            <list>
                <value>"aaa"</value>
                <value>"bbb"</value>
                <value>"ccc"</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="1" value-ref="user1"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="1">ppp</prop>
                <prop key="2">ppp</prop>
                <prop key="3">ppp</prop>

            </props>
        </property>
     </bean>

引用其他配置文件 分模块开发
代码：

<import resource="applicationContext-xxx.xml"/>

在这里插入图片描述

Spring相关API

ApplicationContext的实现类
在这里插入图片描述
getBean()方法的使用：
id可以
写类名也可以
在这里插入图片描述
在这里插入图片描述

Spring配置数据源（连接池的作用）

数据源（连接池） 的作用：

  1. 提高程序的性能
  2. 实现实例化数据源，初始化部分连接资源
  3. 使用连接资源时从数据源中获取
  4. 使用完毕后将连接子渊归还给数据源

常见数据源：DBCP,C3P00,BoneCP，Druid等

数据源开发步骤：

  1. 导入数据源的坐标和数据可驱动坐标
  2. 创建数据源对象
  3. 设置数据源的基本连接数据
  4. 使用数据子渊获去连接资源和规划资源

两种获取数据源的方式：

 public void test2() throws Exception {
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8");
        dataSource.setPassword("123123");
        dataSource.setUsername("root");

        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();

    }

    @Test
    //测试cp30数据源
    public void test1() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8";
        dataSource.setJdbcUrl(url);
        dataSource.setUser("root");
        dataSource.setPassword("123123");

        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

通过properties获取数据源：

//将必要的数据写在properties中
jdbc.url=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123123

    //测试cp30数据源（加载properties版本）
public void test3() throws Exception {
    ResourceBundle rb=ResourceBundle.getBundle("jdbc");
    String driver=rb.getString("jdbc.driver");
    String username=rb.getString("jdbc.username");
    String password=rb.getString("jdbc.password");
    String url=rb.getString("jdbc.url");
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setPassword(password);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setDriverClass(driver);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

借助Spring配置数据源

 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8"/>
        <property name="password" value="123123"/>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
    </bean>

Spring加载Property配置文件
在这里插入图片描述
核心：在这里插入图片描述

Spring注解开发

Spring是轻代码重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。

Spring原始注解

主要是用于替代的配置

在这里插入图片描述
注意：使用注解的时候要在bean中配置组件扫描
在这里插入图片描述
在这里插入图片描述
通过@Value注入普通数据类型
@Vulue(${} )注入 properties中的数据
@Scope 设置到底让你产生几个Bean

Spring新注解

原始注解无法解决的事情：
在这里插入图片描述
在这里插入图片描述

SpringJunit 测试

集成步骤

在这里插入图片描述

Spring集成web环境

在这里插入图片描述
通过设置监听器获取spring容器文件

  1. 编写监听类（实现 ServletContextListenser接口）
public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        //将想要放进容器中的东西创建出来
        ApplicationContext app=new ClassPathXmlApplicationContext("SpringConfiguration.xml");
        //新建一个serclet容器
        ServletContext servletContext =servletContextEvent.getServletContext();
        //将app放入接口中
        servletContext.setAttribute("app",app);
        System.out.println("监听器实现创建过了");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}
  1. 在web文件中放入监听器映射
 <listener>
        <listener-class>com.itheima.listener.ContextLoaderListener</listener-class>
    </listener>
  1. 在web层取出这个文件
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //获取这个容器
        ServletContext servletContext = req.getServletContext();
        //获取容器中的东西
        ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        //实现
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

在web中设置全局变量

  1. 在web文件中设置全局参数
 <!--web全局配置参数-->
    <context-param>
        <param-name>springConfiguration</param-name>
        <param-value>SpringConfiguration.xml</param-value>
    </context-param>
  1. 通过应用上下文获取设置在web中设置的全局参数
  		ServletContext servletContext = req.getServletContext();
        //读取web中的全局变量
        String springConfiguration = servletContext.getInitParameter("springConfiguration");

通过工具类获取上下文应用的值
好处：以为ServletContext 的attribute的值是耦合死的，不方便编程，所以设计工具类来方便编程将想要获取的放在上下文应用中

  1. 先存入
		ApplicationContext app=new ClassPathXmlApplicationContext("SpringConfiguration.xml");
        //新建一个serclet容器
        ServletContext servletContext =servletContextEvent.getServletContext();
        //将app放入接口中
        servletContext.setAttribute("app",app);
        System.out.println("监听器实现创建过了");
  1. 编写工具类
public class WebApplicationContext {
    public static ApplicationContext getApplication(ServletContext servletContext){
        return (ApplicationContext) servletContext.getAttribute("app");
    }
}
  1. 通过工具类获取到这个值
 ApplicationContext app= WebApplicationContext.getApplication(servletContext);

对于上述的这个工具类，Spring提供了一个包装类供使用

在这里插入图片描述

SpringMVC简介

在这里插入图片描述
开发过程

  1. 导入SpringMVC坐标
  2. 配置SpringMVC核心控制器和DispathServlet
  3. 创建Controller类和视图页面
  4. 使用注解配置Controller类汇总业务方法映射地址
  5. 配置SpringMVC核心文件spring-mvc.xml
  6. 客户端发起测试

Spring访问过程：
在这里插入图片描述
在这里插入图片描述

开发步骤：

  1. 导入springmvc的坐标
  2. 配置sprigmvc核心控制器DispathServlet
  3. 创建Controller类和视图页面
  4. 使用注解配置Controller类中业务方法的映厍地址
  5. 配置SpringMVC核心文件spring-mvc.xml
  6. 客户端发起请求测试

SpringMvc的组件解析

执行流程
在这里插入图片描述
在这里插入图片描述
注解解析：
@RequestMapping
作用：用于建立请求URL和处理方法之间的对应关系
位置：
类上：请求URL的第一集访问目录。此处不写的话就相当于应用 的根目录
方法上：请求URL的第二集目录，与类上的使用@RequestMapping标注的以及目录一起组成访问虚拟路径
属性：
在这里插入图片描述
注解解析：
在这里插入图片描述
xml文件的配置

  1. 内部资源视图解析器
    在这里插入图片描述

相关组件：
前段控制器：DispatcherServlet
处理映射器：HandlerMapping
处理适配器：HandlerAdapter
处理器：Handler
视图解析器：View Resolver
视图：View

注解和配置：
请求映射器：@RequestMapping
视图解析器配置：
REDIRECT_URL_PREFIX=“redirect：”
FORWARD_URL_PREFIX=“forward：”
prefix=
suffix=

SpringMVC的数据响应：

（1）页面跳转
直接返回字符串
通过ModelAndView对象返回
（2）回写数据
直接返回字符串
返回对象或集合
页面跳转：
1.返回字符串的形式：
在这里插入图片描述
2.返回ModelAndeViewer

以下5中方式均可以：

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick5")
    public String save5(HttpServletRequest servletRequest){
        servletRequest.setAttribute("username","张强");
        return "success";
    }

    @RequestMapping("/quick4")
    //modelView对象spring框架会自动注入创建
    public String save4(Model model){
        model.addAttribute("username","博学谷");
        return "success";
    }

    @RequestMapping("/quick3")
    //modelView对象spring框架会自动注入创建
    public ModelAndView save3(ModelAndView modelAndView){
        modelAndView.addObject("username","itheima");
        modelAndView.setViewName("success");
        return modelAndView;
    }

    @RequestMapping("/quick2")
    public ModelAndView save2(){
        //model：封装数据
        //view：展示数据
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("username","itheima");
        //设置model名称
        modelAndView.setViewName("success");
        return modelAndView;
    }
    @RequestMapping("/quick")
    public String save(){
        System.out.println("到达Controller层");
        return "success";
    }
}

回写数据

  1. 直接返回字符
    Web基础阶段，客户端访问服务器端，如果想直接返回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“Hello word”)即可，那么在Controller中想直接回写字符串该怎么样呢？
    方法1. 通过response方法进行书写
public void save6(HttpServletResponse response) throws IOException {
        response.getWriter().println("zq");
    }

方法2.直接返回字符串，但是注意要对方法进行SpringBody的注释，告知Springmvc框架，不进行视图调准，直接进行数据响应。

 @ResponseBody
    public String save5() throws IOException {
        return "ZQ";
    }

将对象转为joson格式返回到页面上

 	@RequestMapping("/quick8")
 	//告诉服务器，我返回的是字符串，不是个View
    @ResponseBody
    public String save8() throws IOException {
        User user=new User();
        user.setUsername("zq");
        user.setAge(18);
        //使用ObjectMapper类，需要配置依赖
        ObjectMapper objectMapper = new ObjectMapper();
        String s = objectMapper.writeValueAsString(user);
        return s;
    }

//objectMapper的依赖

  <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.9.0</version>
    </dependency>
  1. 返回数据或集合
    配置xml文件，直接将对象转为json传过去
 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
  </bean>

配置xml文件比较麻烦，所以 可以通过配置注解来解决上面的事情,但是别忘记加入网址。

在这里插入图片描述
在这里插入图片描述

SpringMvc获得请求参数

客户端请求参数的格式是：name=vlaue&name=value
服务端要获得请求参数，优势还需要进行数据的封装，SpringMVC可以接收如下啊类型的参数

  1. 基本类型参数
  2. POJO类型参数
  3. 数组类型参数
  4. 集合类型参数

获得基本类型参数
Controller中的业务方法的参数名要与请求参数的name一致，参数会自动映射匹配
获得POJO类型参数
Controller中的业务方法的POJO参数名要与请求参数的name一致，参数会自动映射匹配
获得数组类型的参数
Controller中的业务方法数组名称与请求参数的name一致
封装集合类型的参数
获得集合参数时，要将集合参数包装到一个对象中才可以，但是在对象集合前加入@RequestBody就可以直接进行获取。

请求乱码问题的解决

在web.xml配置全局过滤器即可

<!--    配置资源过滤器解决乱码问题-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

@RequestParam注解
将参数绑定，将请求的不是参数列表中对应的值得时候可以进行过参数的绑定，从而导致仍然能够打印这和名字。
在这里插入图片描述

获取Restful风格的参数
在这里插入图片描述
通过@PathVariable注解记性占位符的匹配获取工作
在这里插入图片描述
自定义类型装换器
springmvc已经提供了一些蟾宫的类型转换器，例如将客户的字符串转为int
但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。
步骤：

  1. 自定义转换器实现Converter接口
  2. 在配置文件中声明转换器
  3. 在中引用转换器

获得Servlet相关的API
在这里插入图片描述
获取请求头
在这里插入图片描述

文件上传

单文件上传：
1.文件上传客户端三要素
表单项type=“file” 表单的提交方式是post 表单的enctype属性是多部分呢表单形式，即enctype=“multipart/form-data”
2.文件上传原理
在这里插入图片描述
单文件上传实现：
在这里插入图片描述
在这里插入图片描述
3.注意，这里的名字要和jsp中名字一一致在这里插入图片描述
多文件上传：
只需要在jsp中多准备一个控件，然后在Controller层中设置一个数组，进行循环操作。

JdbcTemplate

在这里插入图片描述
在这里插入图片描述
具体代码demo如下：

  1. 导入坐标，这里面有一个注意事项，mysq-connector-java的版本要和mysql对应，不对应会导致连接出错的情况。
<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
</dependency>
<dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
</dependency>
  1. 创建数据库对应的实体类，类型和名字要对应上
 public class Account {
    private double money;
    private String name;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
  1. 创建jdbcTemplate对象，并且执行数据操作
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8");
        dataSource.setUser("root");
        dataSource.setPassword("123123");


        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);

        int row = jdbcTemplate.update("insert into account1 values(?,?)", "zs", 18);
        System.out.println(row);

可以通过配置xml文件来实现JdbcTempplate的创建和数据库的连接

  1. 新建jdbc.properties文件 new file
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.password=123123
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8
jdbc.user=root
  1. 配合xml文件
<!--    配置ComboPooledDataSource-->
    <bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
        <property name="user" value="${jdbc.user}"/>
    </bean>
<!--    配置jdbcTemplate-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <property name="dataSource" ref="comboPooledDataSource"/>
    </bean>
  1. 调用
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate = app.getBean(JdbcTemplate.class);
        int row = jdbcTemplate.update("insert into account1 values (?,?)", "ls", 188);
        System.out.println(row);

增删改查模板

 @Test
 //查数量
    public void query(){
        Long aLong = jdbcTemplate.queryForObject("select count(*) from account1", Long.class);
        System.out.println(aLong);
    }

    @Test
    public void queryOne(){
    //查一个 
        Account account = jdbcTemplate.queryForObject("select * from account1 where name =?", new BeanPropertyRowMapper<Account>(Account.class), "zs");
        System.out.println(account);
    }
    @Test
    //查全部
    public void queryAll(){
        List<Account> accounts = jdbcTemplate.query("select * from account1", new BeanPropertyRowMapper<Account>(Account.class));
        System.out.println(accounts);
    }

    @Test
    public void delete(){
    //删除
        jdbcTemplate.update("delete from account1 where name=?","ls");
    }
    @Test
    public void update(){
    //更新
        jdbcTemplate.update("update account1 set money=99999 where name=?","zs");
    }
    @Test
    public void insert(){
    //插入
        jdbcTemplate.update("insert into account1 values(?,?)","ls",1565651);
    }

SpringMVC拦截器

作用：
在这里插入图片描述
过滤器和拦截器的区别：
在这里插入图片描述
快速入门：
在这里插入图片描述
1.

public class Myinterceptor1 implements HandlerInterceptor {
    //在目标方法执行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }
    //在目标方法执行之后，视图对象返回之前执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    //在整个流程都执行完毕之后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

<!--    配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
<!--            对那些资源进行拦截-->
            <mvc:mapping path="/**"/>
            <bean class="com.itheima.interceptor.Myinterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>

多个拦截器的执行的先后顺序就是看谁在上谁在下
拦截方法说明
在这里插入图片描述

SpringMVC异常处理机制

异常处理思路：
在这里插入图片描述
异常处理的两种方式：

  1. 使用SpringMVC提供的简单异常处理器SimpleMappingExceptionResolver
  2. 使用Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理接口

1.使用MVC异常处理器在这里插入图片描述2. 自定义异常处理器
步骤：
在这里插入图片描述

 public class MyExceptionResolver implements HandlerExceptionResolver {

    /*
    关键参数Exception 报异常的异常返回对象，跳转的错误视图的信息
     */
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        ModelAndView modelAndView=new ModelAndView();
        if(ex instanceof MyException){
            modelAndView.addObject("info","自定义的异常");
        }else if(ex instanceof ClassCastException){
            modelAndView.addObject("info","类型转换异常");
        }
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

<bean class="com.itheima.resolver.MyExceptionResolver"/>

SpringAop

什么是aop?
在这里插入图片描述
作用及其优势
在这里插入图片描述
底层实现：
在这里插入图片描述
动态代理技术：
在这里插入图片描述
在这里插入图片描述

  1. jdk
public class ProxyTset {

    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //增强对象
        final Advice advice = new Advice();

        TargetInterface targetInterface=(TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        advice.before();
                        Object invoke = method.invoke(target, args);
                        advice.after();
                        return invoke;
                    }
                }
        );
        targetInterface.save();
    }
}
  1. cglib的动态代理
public class ProxyTset {

    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //增强对象
        final Advice advice = new Advice();

        //返回值就是动态生成的代理技术
        //1.创建增强器
        Enhancer enhancer = new Enhancer();
        //2.设置父类（目标 ）
        enhancer.setSuperclass(Target.class);
        //3.设置回调
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //前置增强
                advice.before();
                method.invoke(target,args);
                advice.after();
                return null;
            }
        });
        //4.创建代理对象
        Target proxy= (Target) enhancer.create();
        proxy.save();

    }
}

相关概念：

在这里插入图片描述

解释：
连接点被拦截到的方法就是连接点，切入点就是拦截到并且真的被增强的方法叫切入点
切面：切点加通知

注意事项：

  1. 需要编写的内容：
    在这里插入图片描述
    技术实现的内容：
    在这里插入图片描述
    aop底层使用哪种代理方式：
    在这里插入图片描述
    知识要点：
    在这里插入图片描述

基于XML的aop开发快速入门

快速入门

在这里插入图片描述
核心就在于xml文文件的配置

<!--配置目标对对象-->
    <bean  id="target" class="com.itheima.proxy.aop.Target"/>
<!--    配置通知-->
    <bean id="myAspect" class="com.itheima.proxy.aop.MyAspect"/>

<!--    配置织入：告诉spring框架，那些方法（切点）需要增强（前置，后置）-->
    <aop:config>
        <aop:aspect ref="myAspect">
            <aop:before method="before" pointcut="execution(public void com.itheima.proxy.aop.Target.save())"/>

        </aop:aspect>
    </aop:config>

切点表达式的写法
语法：
在这里插入图片描述
例子解释：

  1. 指定包下面方法和类
  2. 指定方法下的没有返回值的
  3. 包下的任意类任意方法
  4. aop包以及子包都能增强
  5. 都任意

通知的类

在这里插入图片描述切点表达式抽取

 <aop:config>
        <aop:aspect ref="myAspect">
            <aop:pointcut id="pointcut1" expression="execution(* com.itheima.proxy.aop.*.* (..))"/>
            <aop:around method="around" pointcut-ref="pointcut1"/>
        </aop:aspect>
    </aop:config>

基于注解的aop开发快速入门

步骤：
在这里插入图片描述

  1. 注入目标类
@Component("target")
public class Target implements TargetInterface {
    public void save() {
        System.out.println("run save*********");
    }
}
  1. 配置切面
    类名的上面
@Component("myAspect")
@Aspect
public class MyAspect {

对应的增强方法

   @Before("execution(* com.itheima.proxy.anno.*.* (..))")
    public void before(){
        System.out.println("前置增强************");
    }

3.在xml文件中配置目标类和自动代理

    <context:component-scan base-package="com.itheima.proxy.anno"/>
<!--    自动代理-->
    <aop:aspectj-autoproxy/>

注解配置的AOP 类型
在这里插入图片描述

事务控制

编程式事务控制

接只定义行为
在这里插入图片描述
事务定义对象：定义信息对象
在这里插入图片描述
事务隔离级别
在这里插入图片描述
事务传播行为
在这里插入图片描述
被动的封装事务的信息
在这里插入图片描述

声明式事务控制

什么是声明式事务控制：

在这里插入图片描述

<!--    配置平台事务管理器-->
    <bean id="transactionManager"  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <tx:annotation-driven/>
<!--    通知事务增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--        设置事务的属性信息-->
        <tx:attributes>
<!--           这里面可以增加多个方法-->
            <tx:method name="*" isolation="DEFAULT" propagation="REQUIRED" timeout="-1" read-only="false"/>
        </tx:attributes>
    </tx:advice>

<!--    AOP事务的织入-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.itheima.service.impl.*.*(..))"/>
    </aop:config>

在这里插入图片描述
声明式事务控制的要点：

  1. 平台事务配置器
  2. 事务通知的配置
  3. 事务aop织入的配置

基于注解的声明式控制

在这里插入图片描述

在这里插入图片描述

MyBatis

原始的jdbc连接数据库
在这里插入图片描述
插入数据
在这里插入图片描述
原始jdbc操作分析
在这里插入图片描述
什么是mybatis

在这里插入图片描述

快速入门

步骤：
在这里插入图片描述
4.

<mapper  namespace="userMapper">
    <select id="findAll" resultType="com.itheima.domain.User">
        select * from user
    </select>
</mapper>

<!--    配置数据源环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="123123"/>
            </dataSource>
        </environment>
    </environments>
<!--导入userMapper资源-->
    <mappers>
        <mapper resource="com/itheima/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

public class myBatisTest {
@Test
public void test1() throws IOException {
//通过Resource获取资源文件
InputStream resourceAsStream = Resources.getResourceAsStream(“sqlMapperConfig.xml”);
//新建Session工厂
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
//获取Session对话
SqlSession sqlSession = build.openSession();
//调用命名空间，进行查询
User user = new User();
user.setId(7);
user.setUsername(“lilian”);
user.setPassword(“123123”);
sqlSession.insert(“userMapper.insert”,user);

    List<User> userList = sqlSession.selectList("userMapper.findAll");
    System.out.println(userList);
    //释放资源
    sqlSession.close();
}

}

映射文件概述

在这里插入图片描述

增删改查操作

插入：
在这里插入图片描述

<!--    插入操作-->
    <insert id="insert" parameterType="com.itheima.domain.User">
        insert into user values (#{id},#{username},#{password})
    </insert>

<!--    修改数据-->
    <update id="update" parameterType="com.itheima.domain.User">
        update user set username=#{username},password=#{password} where id=#{id}
    </update>

<!--    删除数据-->
    <delete id="delete" parameterType="com.itheima.domain.User">
        delete from user where id=#{id}
    </delete>

知识小结：
增删改查映射配置与API：
在这里插入图片描述

MyBatis核心配置文件层级关系

在这里插入图片描述environment标签
数据库环境的配置，支持多环境配置

在这里插入图片描述
在这里插入图片描述
mapper
作用是用于加载映射的，加载方式有一下几种：
在这里插入图片描述
properties
实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties。
在这里插入图片描述
typeAliases
类型别名是为Jva类型设置一个短的名字，原来的类型名称配置如下：
在这里插入图片描述
已经将常用的类型定义好了别名

在这里插入图片描述

知识小结:
在这里插入图片描述

MyBatis响应的API

SqlSession工厂构造器SqlSessionFactoryBuilder
常用API：SqlSessionFactory build(InputStream inputStream)
在这里插入图片描述
在这里插入图片描述

MyBatis的Dao层实现

代理开发方式：
在这里插入图片描述
在这里插入图片描述

MyBatis映射文件深入

  1. 动态sql语句描述
    在这里插入图片描述
    在这里插入图片描述
    动态SQL if
    在这里插入图片描述
    动态SQL foreach
    在这里插入图片描述
    Sql片段抽取

在这里插入图片描述
总结：
在这里插入图片描述

MyBatis 核心配置文件深入

typeHandlers标签

在这里插入图片描述

重新定义类型转换器
在这里插入图片描述
开发步骤
1.

public class DateTypeHandler extends BaseTypeHandler<Date> {
    //将java类型转化成数据库中需要的类型
    public void setNonNullParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
        long time = parameter.getTime();
        ps.setLong(i,time);
    }

    //将数据库中的类型转换成java类型
    //columnName是数据库中要转换的字段的名称
    //rs查询的结果集
    public Date getNullableResult(ResultSet rs, String columnName) throws SQLException {
        //将获取到的数据转换成long类型
        long aLong = rs.getLong(columnName);
        //然后转换成date类型
        Date date = new Date(aLong);
        return date;
    }

    //将数据库中的类型转换成java类型
    public Date getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        long aLong = rs.getLong(columnIndex);
        Date date = new Date(aLong);
        return date;
    }

    //将数据库中的类型转换成java类型
    public Date getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        long aLong = cs.getLong(columnIndex);
        Date date = new Date(aLong);
        return date;
    }
}

<!--自定义注册器-->
    <typeHandlers>
        <typeHandler handler="itheima.handler.DateTypeHandler" javaType="java.util.Date"/>
    </typeHandlers>

plugins标签

在这里插入图片描述

  1. 在pom文件中导入坐标
  <!-- mybatis pager -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.0</version>
        </dependency>

        <dependency>
            <groupId>com.github.miemiedev</groupId>
            <artifactId>mybatis-paginator</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.4</version>
        </dependency>
  1. 配置核心文件中的插件
<!--    配置plugins分页助手-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <property name="dialect" value="mysql"/>
        </plugin>
    </plugins>

3.在测试中编写测试的代码

PageHelper.startPage(1,2);

拓展：获取与分页相关的参数
在这里插入图片描述

MyBatis多表操作

多表查询中，将多表查询的结果和现实中的结果一一对应
一对一

    <resultMap id="orderMap" type="order">
<!--        column是数据库中查询到的列，property是我们要封装进的实体-->
        <result column="oid" property="id"/>
        <result column="ordertime" property="ordertime"/>
        <result column="total" property="total"/>
        <result column="uid" property="user.id"/>
        <result column="username" property="user.username"/>
        <result column="password" property="user.password"/>
        <result column="birthday" property="user.birthday"/>
    </resultMap>
<!--这里结果要改成resultMap-->
    <select id="findAll" resultMap="orderMap">
        select *,o.id oid
        from orders o inner join user u on u.id=o.uid
    </select>

将查询到的关联表封装在另一个类中的另一种封住方式：

 <resultMap id="orderMap" type="order">
        <result column="oid" property="id"/>
        <result column="ordertime" property="ordertime"/>
        <result column="total" property="total"/>
        <!--        property是order中的属性
            javaType是实际的类
		-->
        <association property="user" javaType="user">
            <result column="uid" property="id"/>
            <result column="username" property="username"/>
            <result column="birthday" property="birthday"/>
            <result column="password" property="password"/>
        </association>
    </resultMap>

一对多

    <resultMap id="userMapper" type="user">
        <result property="id" column="uid"/>
        <result property="username" column="username"/>
        <result property="password" column="password"/>
        <collection property="orderList" ofType="order">
            <result column="oid" property="id"/>
            <result column="ordertime" property="ordertime"/>
            <result column="total" property="total"/>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="userMapper">
        SELECT *,o.id oid FROM orders o INNER JOIN USER u ON u.id=o.uid
    </select>

多对多
在这里插入图片描述
总结：
在这里插入图片描述

MyBatis的注解开发

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
**一对多 **
在这里插入图片描述

SSM框架整合

原始方式整合

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Spring整合Mybatis

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

江南小张
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
配置Spring数据源
难得糊涂
08-22 1259
配置一个数据源     Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是 C3P0。可以在Spring配置文件中利用这两者中任何一个配置数据源。  DBCP数据源     DBCP类包位于 &lt;spring_home&gt;&lt;/spring_home&gt;/lib/jakarta-commons/commons-dbcp.jar，DBCP...
javaSpring学习笔记
最新发布
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
hibernate CP30连接池配置
申公的专栏
02-25 2042
一.hibernate4.0之前的配置CP30 org.hibernate.dialect.SQLServerDialect jdbc:sqlserver://localhost:1433;databaseName=test org.hibernate.connection.C3P0ConnectionProvider 100 10 120 100 120
【java学习】Spring MVC（Model View Controller）、ApplicationRunner
午后阳光
09-28 1480
1，概念 SpringMVC： Spring推出的基于Servlet标准的MVC框架实现 1）Spring MVC特性 Spring MVC提供了一种绑定机制（请求参数名称与Java类的属性相匹配即可），通过该机制可以从用户请求中提取数据，然后将数据转换为预定义的数据格式，最后映射到一个模型类，从而创建一个对象。 Spring MVC还是非侵入式的，因为业务逻辑代码与框架本身是分离的。 2）Controller（控制器） 一个java组件，用于：通客户端交互，控制并管理每个请求的处理。 @Contr
JDBC(三)数据库连接池，动态代理
wake
05-13 781
一、数据库连接池 为了避免每次访问数据库的时候都需要重新建立新的连接而影响运行速度，如果网站访问量比较大，极容易造成内存溢出，在实际的项目中必须使用数据库连接池来提高数据库的访问效率。              当用户在使用连接池获取链接后，一般都会调用Connection.close()方法，关闭链接。而我们需要的是把链接还回池中 装饰设计模式编码步骤 1、编写一个类，实现与
04-Spring注入（Injection）
前路无畏的博客
11-01 1万+
上一篇：03-Spring和日志框架log4j整合https://blog.csdn.net/fsjwin/article/details/109407627 1.什么是注入 通过spring工厂和配置文件为spring的成员变量赋值，就叫注入 工厂 配置文件 成员变量赋值 2.为什么需要注入 一般的写法 @Test public void test6() { ApplicationContext ctx = new ClassPathXmlApplicationCo
C3P0 配置详细说明
给太阳洒水的博客
12-19 100
&lt;c3p0-config&gt;&lt;default-config&gt;&lt;!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 --&gt;&lt;property name="acquireIncrement"&gt;3&lt;/property&gt;&lt;!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 --&gt
spring 学习笔记
05-08
下面将根据“spring 学习笔记”的主题，对Spring框架进行深入的探讨。 一、依赖注入（DI） 依赖注入是Spring的核心功能，它允许对象之间的依赖关系在运行时动态地管理和配置，而不是在代码中硬编码。这样可以提高...
Spring学习笔记 自我总结
11-02
spring学习笔记
spring学习笔记
02-07
本笔记是spring4的，所有内容亲测，方便初学者学习之用。
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
Spring Cp30配置
weixin_30656145的博客
12-12 89
1.配置db.properties 　　 <bean id= "propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" > <property name="location"...
c3p0数据库连接池配置总结
热门推荐
ZHL's Blog
07-04 6万+
c3p0方法配置 c3p0配置文件配置 前言 关于c3p0一般有这么两种配置，一种是通过set方法进行配置，另一种是通过在同src目录下的c3p0-conflg.xml文件或者c3p0.properties文件进行相关的配置。 c3p0通过set方法进行配置 private static ComboPooledDataSource dataSou...
数据库连接池C3P0学习
conge
12-24 767
数据库连接池C3P0框架是个非常优异的开源jar，高性能的管理着数据源，这里只讨论程序本身负责数据源，不讨论容器管理。   一、实现方式： C3P0有三种方式实现： 1.自己动手写代码，实现数据源 例如：在类路径下配置一个属性文件,config.properties，内容如下： driverClass=xxx jdbcUrl=xxx user=xxx password=xxx ...
hibernate cp30 配置
w_j_w2010的博客
06-18 485
org.hibernate.dialect.MySQLDialect     com.mysql.jdbc.Driver     jdbc:mysql://localhost:3306/db?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8     aabbcc     aa
c3p0 参数配置参考
lwdlouis的专栏
11-27 1758
二、部分参数配置说明：  1.最常用配置initialPoolSize:连接池初始化时创建的连接数,default : 3（建议使用）minPoolSize:连接池保持的最小连接数,default : 3（建议使用）maxPoolSize:连接池中拥有的最大连接数，如果获得新连接时会使连接总数超过这个值则不会再获取新连接，而是等待其他连接释放，所以这个值有可能会设计地很大,default : 15...
配置Spring数据源c3p0与dbcp
zhangzuanqian
07-21 391
copy from http://blog.sina.com.cn/s/blog_5e3fc5cf0100dnvx.html   不管通过何种持久化技术，都必须通过数据连接访问数据库，在Spring中，数据连接是通过数据源获得的。在以往的应用中，数据源一般是 Web应用服务器提供的。在Spring中，你不但可以通过JNDI获取应用服务器的数据源，也可以直接在Spring容器中配置数据源，此外，...
c3p0详细配置（c3p0-config.xml）及使用
caychen的博客
03-20 5万+
参数详细说明请跳转：数据库连接池c3p0常用配置说明&lt;c3p0-config&gt;&lt;default-config&gt;                &lt;!-- 数据库驱动名 --&gt;                 &lt;property name="driverClass" &gt;&lt;/properties&gt;                &lt;!-- ..
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值