学习记录七

最新推荐文章于 2024-03-07 12:59:23 发布

young_man2

最新推荐文章于 2024-03-07 12:59:23 发布

阅读量147

点赞数

分类专栏：力扣 Spring java 文章标签：学习 java spring

本文链接：https://blog.csdn.net/young_man2/article/details/125569315

版权

java 同时被 3 个专栏收录

103 篇文章 2 订阅

订阅专栏

力扣

43 篇文章 0 订阅

订阅专栏

Spring

23 篇文章 0 订阅

订阅专栏

一、力扣打卡

正则表达式匹配

拿到这个题目的时候，就可以知道“ . ”表示匹配任意一个字符，“ * ”表示匹配任意多个前面那个字符。

首先判断字符规律中是不是只含有“ .* ”，是的话就一定会匹配成功

然后判断是不是含有" . "或者“ * ”，如果不含有就先匹配字符串和字符规律的长度，长度不相等那么一定匹配失败。

最后判断其他情况

=========================================================================

二、Spring的事务控制

编程式事务控制指的是通过写代码的方式对事务进行控制

1.编程式事务控制相关对象

①PlatformTransactionManager（平台事务管理器）

所以在使用声明式事务控制的时候就需要告诉spring我使用的是哪一种实现技术！

②TransactionDefinition(封装事务的信息)

（1）事务的隔离级别

（2）事务的传播行为（在解决业务方法调用的时候的统一性的问题）

【REQUIRED：A业务方法调用B业务方法的时候，如果A业务方法没有事务，B为他新建一个事务；如果A业务方法有事务，B就加入进去！】

③TransactionStatus(事务的状态对象)

2.基于XML的声明式事务控制

①什么是声明式事务控制？

采用声明的方式来处理事务。这里所说的声明就是指在配置文件中声明，用在Spring配置文件中声明式的处理事务来代替代码式的处理事务。

②声明式事务控制的作用

a. 事务管理不侵入开发的组件。

b.在不需要事务管理的时候，只要在设定文件上修改一下，就可以移去事务管理服务，无需改变代码重新编译，这样维护起来很方便

【Spring声明事务控制底层就是AOP】

【典型案例：账户管理】

声明式事务控制明确事项：

··谁是切点？

··谁是通知？

··配置切面？

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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
">

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="accountDao" class="dao.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <!--目标i对象 内部的方法就是我们的切点-->
    <bean id="accountService" class="service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

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

    <!--通知 事务的增强-->
    <!--transaction-manager指的就是平台事务管理器-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务AOP的织入-->
    <aop:config>
        <!--aop:advisor是专门为事务的增强提供的-->
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* service.impl.*.*(..))"></aop:advisor>
    </aop:config>
</beans>

Account.java

package domain;

public class Account {

    private String name;
    private double money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

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

知识要点：

声明式事务控制的配置要点：平台事务管理器配置→事务通知的配置→事务AOP织入的配置

3. 基于注解的声明式事务控制

4. Spirng集成web层

package com.wxy.web;

import com.wxy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件)方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件)，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

那么就可以使用监听器的方式！

在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicatiotiContext,在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

设置如下：

ContextLoaderListener.java

package com.wxy.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        //将Spring的应用上下文对象存储到ServletContext域中
        ServletContext servletContext = servletContextEvent.getServletContext();
        servletContext.setAttribute("app",app);

    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

UserServlet.java

package com.wxy.web;

import com.wxy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      //  ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = req.getServletContext();
        ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

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_4_0.xsd"
         version="4.0">
    
    <!--配置监听器-->
    <listener>
        <listener-class>com.wxy.listener.ContextLoaderListener</listener-class>
    </listener>
    
    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.wxy.web.UserServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>
    
</web-app>

优化！

上面就会限定加载文件只能是applicationContext.xml文件，那么我们可以配置的方式，让他后期修改只用在web.xml文件中进行修改就可以了

ContextLoaderListener.java

package com.wxy.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ServletContext servletContext = servletContextEvent.getServletContext();
        //读取web.xml中的全局参数
        String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");

        ApplicationContext app=new ClassPathXmlApplicationContext("contextConfigLocation");
        //将Spring的应用上下文对象存储到ServletContext域中

        servletContext.setAttribute("app",app);

    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

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_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>applicationContext.xml</param-value>
    </context-param>

    <!--配置监听器-->
    <listener>
        <listener-class>com.wxy.listener.ContextLoaderListener</listener-class>
    </listener>
    
    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.wxy.web.UserServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>
    
</web-app>

在上面的基础上，我还可以修改应用上下文到最大域的名字，否则需要用户记住名字！

新创建一个工具类，就是用于获取名字

WebApplicationContextUtils.xml

package com.wxy.listener;

import org.springframework.context.ApplicationContext;

import javax.servlet.ServletContext;

public class WebApplicationContextUtils {

    public static ApplicationContext getWebApplicationContext(ServletContext servletContext){
        return (ApplicationContext) servletContext.getAttribute("app");
    }

}

UserService.java

package com.wxy.web;

import com.wxy.listener.WebApplicationContextUtils;
import com.wxy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      //  ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = req.getServletContext();
       //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();
        System.out.println("容器加载");
    }
}

4.1 Spring提供获取应用上下文的工具

UserServlet.java

package com.wxy.web;

import com.wxy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

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.IOException;

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      //  ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = req.getServletContext();
       //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
//        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);

        WebApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();
        System.out.println("容器加载");
    }
}

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_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!--配置监听器-->
    <!--<listener>
        <listener-class>com.wxy.listener.ContextLoaderListener</listener-class>
    </listener>-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.wxy.web.UserServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>
    
</web-app>

pom.xml

 <!--添加这个依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.3.17.RELEASE</version>
        </dependency>

三、算法复习

动态规划算法：

1. 将问题划分为若干子问题

2. 不同于分治法的是各个子问题之间不是相互独立的，一个子问题会依赖于前一个子问题

3. 动态规划算法可以通过画表的方式来实现

动态规划算法常见案例----背包问题

刚刚看了某位博主的文章，对动态规划算法也有了一定的理解！

对于0-1背包问题，我们可以总结为下面的步骤

①确定数组元素的含义

②确定数组之间的关系

③找到初始条件

对于0-1背包问题，我们设数组v[i][j]，表示我们所求的价值

然后确定数组元素之间的关系

因为可以装进去也可以不装，所以有两种情况

先是重量判断，可以装进去的前提下会有下面的条件

v[i][j]=max(v[i-1][j],v[i]+v[i-1][j-w[i]] )

所以最后的表达式

动态规划问题之青蛙跳台阶问题

一个🐸一次可以跳一个或者两个台阶，请问🐸跳n个台阶有多少种跳法？
还是按照上面的步骤

①确定表达式的含义

首先，我们定义一个一维数组，dp[]，那么dp[i]就表示跳i个台阶有dp[i]种跳法

②确定表达式之间的关系

然后我们可以知道，到了第i个台阶的时候，存在一种关系，就是它可以是跳两个台阶到的，也可以是跳一个台阶到的

所以dp[i]=dp[i-1]+dp[i-2]

③求得初始值

在这里，因为数组从0开始，所以我们可以知道我们需要首先给出dp[0]和dp[1]的值才不会导致到达负数，但是！我们会发现我们给出这两个数据之后，对于dp[2]来说是不对的，因为dp[2]=2，但是用上面的公式求得的解却是1，所以，我们还需要给出dp[2]的值，所以我们就要限定开始为dp[1]和dp[2] !!

最后放代码

public int gugua(int n){

    if(n<=1)
        return n;

    int dp[n];

//给出初始数据
    dp[1]=1;
    dp[2]=2;
    
//使用动态规划求解
    for(int i=3;i<=n;i++){
        dp[i]=dp[i-1]+dp[i-2];
    }
//返回所得值
    return dp[n];

}