Spring学习笔记

最新推荐文章于 2024-05-13 16:59:19 发布
最新推荐文章于 2024-05-13 16:59:19 发布
阅读量692 收藏
点赞数
分类专栏： Java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40613029/article/details/107121612
版权

文章目录

Spring

一、概述

Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IoC(Inverse Of Control；反转控制)和AOP(Aspect Oriented Programming；面向切面编程)为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架

二、体系结构

在这里插入图片描述

  • 核心容器：核心容器由spring-core，spring-beans，spring-context，spring-context-support和spring-expression等模块组成

    • spring-core：提供了框架的基本组成部分，包括IoC和依赖注入功能
    • spring-beans：提供BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要
    • context：建立在有core和beans模块的基础上建立起来的，它以一种类似于JNDI注册的方式反问对象。
    • spring-expression：提供了强大的表达式语言，用于在运行时查询和操作对象图

  • 数据访问与集成：JDBC、ORM、OXM、JMS和事务处理模块

    • JDBC：提供了JDBC抽象层，它消除了冗长的JCBC编码和对数据库供应商特定错误代码的解析
    • ORM：提供了对流行的对象关系映射API的继承，包括JPA、JDO和Hibernate等
    • OXM：提供了对OXM实现的支持
    • JMS：包含生产和消费的功能。
    • 事务：实现特殊接口类以及所有的POJO支持编程方式和声明式事务

  • Web：Web、Web-MVC、Web-Socket和Web-Portlet

    • Web：提供Web基本功能和面向Web的应用上下文，比如部分文件上传功能、使用Servlet监听器初始化IoC容器等
    • Web-MVC：为Web应用提供了模型视图控制(MVC)和REST Web服务的实现。Spring MVC框架可以使领域模型代码和web表单完全地分离
    • Web-Socket：为WebSocket-based提供了支持，而且在web应用程序中提供了客户端和服务器之间的通信方式
    • Web-Portlet：提供了用于Portlet环境的MVC实现，并反映了spring-webmvc模块的功能

  • 其他

    • AOP：提供了面向对象的编程实现，允许你定义定法拦截器和切入点对代码进行干净地解耦，从而实现功能代码彻底解耦出来
    • Aspects：提供了AspectJ的集成，这是一个功能强大且成熟的面向切面编程(AOP)框架
    • Instrumentation：一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现
    • Messaging：为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息

三、Spring IOC

3.1 解决程序的耦合

public interface IAccountDao {
    void saveAccount();
}
public class AccountDao implements IAccountDao {
    @Override
    public void saveAccount() {
        System.out.println("AccountDao");
    }
}
public interface IAccountService {
    void saveAccount();
}
public class AccountService implements IAccountService {
    @Override
    public void saveAccount() {
        System.out.println("AccountService");
    }
}
/**
 * 创建AccountDao和AccountService对象
 * 
 **/
public class Client {
    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        //根据id获取bean对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        IAccountDao adao = ac.getBean("accountDao", IAccountDao.class);
        System.out.println(as);
        System.out.println(adao);
    }
}

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--spring管理对象的创建-->
    <bean id="accountService" class="ysw.service.impl.AccountService"></bean>

    <bean id="accountDao" class="ysw.dao.impl.AccountDao"></bean>

</beans>

3.2 ApplicationContext

  • 三个常用实现类
ApplicationContext ac = new ClassPathXmlApplicationContext();//加载类路径下的配置文件，要求配置文件必须在类路径下。
ApplicationContext ac = new FileSystemXmlApplicationContext();//加载磁盘上任意路径下的配置文件
ApplicationContext ac = new AnnotationConfigApplicationContext();//用于读取注释创建容器
  • 核心容器的两个接口
    • ApplicationContext：构建核心容器时，创建对象采取的策略是采用立即加载的方式，只要读完配置文件马上就会创建出对象
    • BeanFactory：构建核心容器时，创建对象采用延迟加载的方式，什么时候根据id获取对象，则什么时候才真正创建对象

3.3 创建bean的三种方式

  • 使用默认构造函数，配id和class属性后，没有其他属性和标签
  • 使用普通工厂中的方法创建对象，并创建spring容器
<bean id="……" factory-bean="……" factory-method="……"></bean>
  • 使用工厂中的静态方法创建对象(使用某个类中的静态方法创建对象，并存入spring容器)

3.4 bean的作用范围

  • 使用标签的scope属性指定bean的作用范围
    • singleton：单例(默认值)
    • prototype：多例
    • request：作用于web应用的请求范围
    • session：作用于web应用的会话范围
    • global-session：作用于集群环境的会话范围

3.5 bean的生命周期

3.5.1 单例对象
  • 出生：当容器创建时对象出生
  • 活着：只要容器还在，对象一直活着
  • 死亡：容器销毁，对象消亡
  • 总结：单例对象的声明周期和容器相同
3.5.2 多例对象
  • 出生：当使用对象时spring框架会为我们创建对象
  • 活着：对象在使用过程中一直活着
  • 死亡：当对象长时间不用，会由垃圾回收器进行回收

四、Spring依赖注入

4.1 概述

  • 依赖注入：Dependency Injection
  • IOC的作用：降低程序间的耦合
  • 依赖的管理都交给spring管理
  • 当前类需要其他类的对象，则由spring为我们提供，我们只需在配置文件中说明

4.2 依赖注入

  1. 依赖注入的数据：
    • 基本数据类型和String
    • 其他bean类型(在配置文件中或者注解配置过的bean)
    • 复杂类型/集合类型
  2. 注入方式：
    • 使用构造函数提供
    • 使用set方法提供
    • 使用注解提供

  • 构造函数注入

    <bean id="……" class="……">
    <constructor-arg name="……" value="……"></constructor-arg>
    <constructor-arg name="……" ref="……"></constructor-arg>
</bean>
    • 使用标签constructor-org
    • 标签出现的位置在bean标签内
    • 标签的属性：type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型；index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引位置从0开始；name：用于指定给构造函数中指定名称的参数赋值；value：用于提供基本数据类型和String类型的数据；ref：用于指定其他的bean类型数据。指的是spring的Ioc核心容器中出现过的bean对象

  • set方法注入

    <bean id="……" class="……">
    <property name="……" value="……"></property>
    <property name="……" ref="……"></property>
</bean>
    • set方法注入，涉及的标签为property
    • 出现的位置 在bean标签内部
    • 标签的属性：name：用于指定注入时所调用的set方法名称；value：用于提供基本数据类型和String类型数据；ref：用于指定其他的bean类型数据。它指的是在spring的Ioc和兴容器中出现过的对象

  • 复杂类型注入(集合类型注入)

    • 用于给List结构集合注入的标签：list array set
    • 用于Map结构集合注入的标签：map props
    	<bean id="……" class="……">
        <property name="……">
            <list>
                <value>……</value>
                <value>……</value>
                <value>……</value>
            </list>
        </property>
        <property name="……">
            <array>
                <value>……</value>
                <value>……</value>
                <value>……</value>
            </array>
        </property>
        <property name="……">
            <map>
                <entry key="……" value=""></entry>
                <entry key="……">
                    <value>……</value>
                </entry>
            </map>
        </property>
        <property name="……">
            <props>
                <prop key="……">……</prop>
            </props>
        </property>
    </bean>

五、基于注解的IOC

5.1 用于创建对象

<?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
        https://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="包名"></context:component-scan>
    
</beans>

@Component("accountService")
public class AccountService implements IAccountService {
    @Override
    public void saveAccount() {
        System.out.println("AccountService");
    }
}
  • Component：用于把当前类对象存入spring容器中
    • 属性value：用于指定bean的id。当不写时，他默认为当前类名且首字母改小写
  • Controller：一般用在表现层
  • Service：一般用在业务层
  • Repository：一般用在持久层
  • 他们三个注解的作用和属性与Component一模一样
  • 他们三个是spring框架为我们提供明确的三层使用的注解

5.2 用于注入数据

  • Autowired：
    • 自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功
    • 可以出现在变量上或方法上
    • 使用注解注入时，set方法就不是必须的
  • Qualifier：
    • 在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用
    • 属性：value：用于指定注入bean的id
  • Resource：
    • 直接按照bean的id注入。它可以独立使用
    • 属性：name：用于指定bean的id
  • Value：
    • 用于注入基本类型和String类型的数据
    • 属性value：用于指定数据的值。它可以使用spring中SpEL(spring的el表达式)
    • SpEL写法：${表达式}

5.3 用于作用范围

  • Scope：用于指定bean的作用范围
  • 属性value：指定范围的取值：singleton、prototype

5.4 生命周期

  • 他们的作用和在bean标签中使用init-method和destroy-method作用一样
  • PreDestroy：用于指定销毁方法
  • PostConstruct：用于指定初始化方法

六、spring新注解

  1. Configuration
    • 指定当前类为配置类
  2. ComponentScan
    • 用于通过注解指定spring在创建容器时要扫描的包
    • 属性value：与basePackages作用一样，用于指定创建容器时需要扫描的包
  3. Bean
    • 用于当前方法的返回值作为bean对象存入spring的IoC容器中
    • 属性name：用于指定bean的id，当不写时，默认值为当前方法的名称
@Configuration
@ComponentScan("ysw.service")
class SpringConfiguration {

    @Bean("runner")
    public QueryRunner createQueryRunner(DataSource dataSource) {
        return new QueryRunner(dataSource);
    }
    
    @Bean("dataSource")
    public DataSource createDataSource() {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/……");
            ds.setUser("root");
            ds.setPassword("……");
            return ds;
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return null;
    }
}

  1. import

    • 用于导入其他的配置类
    • 属性value：用于指定其他配置类的字节码，有Import注解的类都是父配置类，而导入的类都是子配置类

  2. PropertySource

    • 用于指定properties文件的位置
    • 属性value：指定文件的名称和路径；关键字classpath，表示类路径

  3. Spring整合Junit单元测试

    • 导入spring整合Junit的jar
    • 使用Junit提供的一个注解把原有的main方法替换，替换成spring提供的：@Runwith
    • 告知spring的运行器，spring和IoC创建基于xml还是注解的，并说名位置：@ContextConfiguration
    • location：指定xml文件的位置，加上classpath关键字，表示在类路径下
    • classes：指定注解类所在的位置

七、AOP

7.1 动态代理

7.1.1 基于接口

  1. 特点：字节码随用随创建，随用随加载

  2. 作用：不修改源码的基础上对方法增强

  3. 分类：

    • 基于接口的动态代理
    • 基于子类的动态代理

  4. 基于接口的动态代理：

    • 涉及的类：Proxy
    • 提供者：JDK官方

  5. 创建代理：

    • 使用Proxy类中的newProxyInstance方法

  6. 创建代理对象的要求：

    • 被代理类最少实现一个接口，如果没有则不能使用

  7. newProxyInstance的参数

    • ClassLoader：用于加载代理对象字节码。和被代理对象使用相同的类加载器
    • Class[]：用于让代理对象和被代理对象有相同的方法
    • InvocationHandler：用于提供增强的代码。一般写一个该接口的实现类，通常情况下是匿名内部类

  8. 代码演示

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @Description TODO
 * @Author YunShuaiWei
 * @Date 2020/6/21 8:56
 * @Version
 **/
public class Client {
    public static void main(String[] args) {
        final Producer p = new Producer();
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(p.getClass().getClassLoader(), p.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 执行被代理对象的任何接口方法都会经过该方法
                     * proxy：代理对象的引用
                     * method：当前执行的方法
                     * args：当前执行方法所需的参数
                     * @Param [proxy, method, args]
                     * @return java.lang.Object
                     **/
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object returnValue = null;
                        float money = (float) args[0];
                        if ("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(p, money * 0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(1000f);
    }
}
7.1.2 基于子类
  1. 基于接口的动态代理：
    • 涉及的类：Enhancer
    • 提供者：第三方cglib库
  2. 创建代理：
    • 使用Enhancer类中的create方法
  3. 创建代理对象的要求：
    • 被代理类不能是最终类
  4. create的参数
    • ClassLoader：用于加载代理对象字节码。和被代理对象使用相同的类加载器
    • Class字节码：用于指定被代理对象的字节码
    • Callback：用于提供增强的代码。一般写一个该接口的实现类，通常情况下是匿名内部类
  5. 代码演示
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * @Description TODO
 * @Author YunShuaiWei
 * @Date 2020/6/21 8:56
 * @Version
 **/
public class Client {
    public static void main(String[] args) {
        final Producer p = new Producer();

        Producer cglibProducer = (Producer) Enhancer.create(p.getClass(), new MethodInterceptor() {
            /**
             * 执行此对象的任何方法都会经过该方法
             * 参数和基于接口的动态代理的参数一致
             * @Param [proxy, method, args, methodProxy]
             * @return java.lang.Object
             **/
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Object returnValue = null;
                Float money = (Float) args[0];
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(p, money * 0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(1200f);
    }
}

7.2 概述

AOP为Aspect Oriented Programming的缩写，意为面向切面编程，通过预编译方式运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架的一个重要内容。

  • 作用：
    • 在程序运行期间，不修改源码对已有方法进行增强
  • 优势：
    • 减少重复代码
    • 提高开发效率
    • 维护方便

7.3 AOP相关术语

  1. Joinpoint(连接点)：
    • 指那些被拦截的点，在spring中，这些点指的是方法，因为spring只支持方法类型的连接点
  2. Pointcut(切入点)：
    • 指我们对哪些Joinpoint进行拦截的定义
  3. Advice(通知/增强)：
    • 指拦截到Joinpoint之后所要做的事情就通知
    • 通知类型：前置通知，后置通知，异常通知，最终通知，环绕通知
  4. Introduction(引介)：
    • 引介是一种特殊的通知在不修改类型代码的前提下，Introduction可以在运行期为类动态的添加一些方法或Field
  5. Target(目标对象)：
    • 代理的目标对象
  6. Weaving(织入)：
    • 把增强应用到目标对象来创建新的代理对象的过程
    • Spring采用动态代理织入，而AspectJ采用编译器织入和类装在织入
  7. Proxy(代理):
    • 一个类被AOP织入增强后，就产生一个结果代理类
  8. Aspect(切面)：
    • 是切入点和通知(引介)的结合

7.4 Spring基于XML的AOP配置

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>
  1. 将通知Bean交给spring管理
  2. 使用aop:config标签表明开始AOP的配置
  3. 使用aop:aspect标签表明配置切面
    • id属性：给切面提供一个唯一标识
    • ref属性：指定通知类bean的Id
  4. 在aop:aspect标签内部使用对应标签来配置通知的类型
    • 下面示例是前置通知
    • aop:before：表示配置前置通知；method属性：指定Logger类中哪个方法是前置通知
    • pointcut属性：用于指定切入点表达式，该表达式指的是对业务层中哪些方法增强
<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">


    <!--配置spring的Ioc，把service对象配置进来-->
    <bean id="accountService" class="ysw.service.impl.AccountServiceImpl"></bean>

    <!--配置spring的Ioc，将Logger对象配置进来(通知bean)-->
    <bean id="logger" class="ysw.utils.Logger"></bean>

    <!--配置IOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="
            execution(public void ysw.service.impl.AccountServiceImpl.saveAccount())"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>
  • 全通配写法：* * . . * . *( . . )

7.5 Spring基于注解的AOP配置

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

    <context:component-scan base-package="ysw.service"></context:component-scan>

    <!--配置spring开始注解AOP支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @Description TODO
 * @Author YunShuaiWei
 * @Date 2020/6/21 10:02
 * @Version
 *
 * 模拟通知类
 **/
@Component("logger")
@Aspect
public class Logger {

    @Pointcut("execution(* ysw.service.impl.*.*(..))")
    private void pt1(){}

    @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知！！！");
    }

    @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("后置通知！！！");
    }

    @AfterThrowing("pt1()")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知！！！");
    }

    @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知！！！");
    }

    //@Around("pt1()")
    public void aroundPrintLog(){
        System.out.println("环绕通知！！！");
    }
}

八、Spring中的JDBCTemplate

8.1 基本配置

  • 依赖
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>
  • 代码演示
/**
 * @Description TODO
 * @Author YunShuaiWei
 * @Date 2020/6/21 20:08
 * @Version
 **/
public class JdbcTemplateDemo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        JdbcTemplate jt = ac.getBean("jdbcTemplate", JdbcTemplate.class);

//        jt.update("insert into account(name,money)values (?,?)","ysw",1000);
//        jt.update("update account set name=?,money=? where id=?","test",1234,5);
//        jt.update("delete from account where id=?",5);
//        List<Account> query = jt.query("select * from account where money>?", new AccountRowMapper(), 500);
        List<Account> query = jt.query("select * from account where money>?",
                new BeanPropertyRowMapper<Account>(Account.class), 500);

        for (Account account : query) {
            System.out.println(account);
        }
        Integer count = jt.queryForObject("select count(*) from account where money>?", Integer.class, 500);
        System.out.println(count);
    }
}

/**
 * 封装结果集
 *
 * @Param
 * @return
 **/
class AccountRowMapper implements RowMapper<Account> {

    @Override
    public Account mapRow(ResultSet resultSet, int i) throws SQLException {
        Account a = new Account();
        a.setId(resultSet.getInt("id"));
        a.setName(resultSet.getString("name"));
        a.setMoney(resultSet.getDouble("money"));
        return a;
    }
}

8.2 DAO中的使用

/**
 * @Description TODO
 * @Author YunShuaiWei
 * @Date 2020/6/21 20:58
 * @Version
 **/
public class AccountDaoImpl implements IAccountDao {
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Account findAccountById(Integer accountId) {
        List<Account> query = jdbcTemplate.query("select * from account where id=?",
                new BeanPropertyRowMapper<Account>(Account.class), accountId);
        return query.isEmpty() ? null : query.get(0);
    }

    @Override
    public Account findAccountByName(String accountName) {
        List<Account> test = jdbcTemplate.query("select * from account where name=?", new BeanPropertyRowMapper<>(Account.class), "test");
        if (test.isEmpty()) {
            return null;
        }
        if (test.size() > 1) {
            throw new RuntimeException("结果集不唯一！！！");
        }
        return test.get(0);
    }

    @Override
    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=? ,money=? where id=?",
                account.getName(), account.getMoney(), account.getId()
        );
    }
}
Logistic回归-分类模型和梯度下降算法
sinat_41847989的博客
01-30 992
输入数据：\( [(x_{1},y_{1}),(x_{2},y_{2}),…,(x_{m},y_{m})] \)
Lasso-Logistic回归-R语言应用详解
热门推荐
hetallian的博客
09-01 4万+
Lasso-R示例 LASSO(Least Absolute Shrinkage and Selection Operator)是线性回归的一种缩减方式，本文用R语言对真实医学数据建模，包括分类变量的处理、lasso建模、ROC评估等
logistic回归二分类
10-31
吴恩达网易云公开课《深度学习》week2--logistic回归数据集及代码实现
Logistics回归分类
dayuhaitang1的博客
06-04 2215
因为自己对回归分类比较好奇，所以就找了找资料做了这篇笔记。 一、什么是回归？ 这个问题对我来说一直很朦胧，因为虽然之前做过一些回归的实验，但是如果真是让我用语言说出来又不知道说什么，所以就查了查资料。 回归是指研究一组随机变量(Y1，Y2，…，Yi)(Y1 ，Y2 ，…，Yi)(Y1，Y2，…，Yi)和另一组(X1，X2，…，Xk)(X1，X2，…，Xk)(X1，X2，…，Xk)变量之间关系的统计分析方法。(来源于百度) note：题外话，感觉下面这个故事很有趣，所以也记录一下。Galton(达尔文的
机器学习（四）：Logistic回归分类
Roe_D的博客
07-14 1805
Logistic回归算法 Logistic回归是众多分类算法中的一员。通常，Logistic回归用于二分类问题，例如预测明天是否会下雨。当然它也可以用于多分类问题，不过为了简单起见，本文暂先讨论二分类问题。首先，让我们来了解一下，什么是Logistic回归。 1： Logistic回归（相当于sigmoid 函数） 假设现在有一些数据点，我们利用一条直线对这些点进行拟合(该线称为最佳拟合直线)，...
Logistic回归分类
Java&&大数据专栏
08-26 1893
利用Logistic回归进行分类的核心思想：根据现有数据堆分类边界线简历回归公司，以此进行分类。     基于sigmoid函数的Logistic回归分类器实现：在每个特征上都乘以一个回归系数，然后把所有的结果相加，将总和带入sigmoid函数，得到一个范围在0~1之间的数值。任何大于0.5的数据被分入1类，小于0.5的被归入0类。
Logistic回归（一）分类
宁静致远的博客
06-27 1335
看完Logistic回归，绿一下思路：
(完整word)Logistic回归-样本量估算.doc
11-15
Logistic回归是一种广泛应用的统计分析方法，特别是在医学研究和生物统计学中，用于处理二元结局（如患病/未患病，存活/死亡）与多个预测变量之间的关系。它基于最大似然估计，能够提供关于各个预测因子对结局影响的...
Logistic回归-医学统计学.ppt
10-20
" Logistic回归-医学统计学" Logistic回归是一种常用的统计模型，在医学统计学中应用广泛。它是一种概率模型，适合于病例-对照研究、随访研究和横断面研究，且结果发生的变量取值必须是二项或多项分类。 logistic...
logistic回归--手写识别实例的实现
05-10
Logistic回归是一种广泛应用的分类算法，它在机器学习和统计学中扮演着重要角色。在这个“logistic回归--手写识别实例的实现”项目中，我们将深入探讨如何使用Logistic回归来解决手写数字识别的问题。手写识别是模式...
logistic分类
weixin_30401605的博客
06-18 156
对Logistic回归模型，个人做的一些总结： 公式就不套用了，教材上面基本都有而且详细。logistic回归用图形化形式描述如下： logistic回归是一种简单高效的分类模型，它不仅可以通过学习来预测样本的类别，还可以得到样本属于各个类别的概率信息。因此在机器学习中得到了及其广泛的应用。 同时，它还有比较与其他模型的一些优点： （1）logistic回归模型是线性模型，...
Logistic回归算法（分类问题）
ccc369639963的博客
03-08 1644
Logistic回归算法（分类问题） 我们知道有监督学习分为“回归问题”和“分类问题”，前面我们已经认识了什么是“回归问题”，从本节开始我们将讲解“分类问题”的相关算法。在介绍具体的算法前，我们先聊聊到底什么是分类问题。 什么是分类问题？ 其实想要理解“分类”问题非常的简单，我们不妨拿最简单的“垃圾分类处理”的过程来认识一下这个词。现在考虑以下场景： 小明拎着两个垃圾袋出门倒垃圾，等走到垃圾回收站的时候，小明发现摆放着两个垃圾桶，上面分别贴着“可回收”与“不可回收”。小明经过自己的判断后，把自己右手的垃圾放
【机器学习算法】Logistic回归分类算法
ZhShy
01-28 2499
文章目录一、Logistic回归1. 分类问题2. Logistic函数(1) 阶跃函数（不可导）(2)可导的阶跃函数二、Logistic回归的算法原理1. 基本思路 上一篇：【机器学习算法】线性回归算法 一、Logistic回归 我们知道，回归问题的预测值是连续的，而分类问题的预测值是非连续的，或者称为是离散的。我们还知道，线性模型的一大特点就是“耿直”，是一条纯纯粹粹、不肯走弯路的直线。直线是连续的，所以能被用于回归问题，可又怎么用来解决离散的分类问题呢？ 这么说也许听起来很厉害，但总感觉不太直观，画个
机器学习-利用Logistic回归进行分类
lyn5284767的专栏
07-10 6392
优点：计算代价小，容易实现和理解；缺点：容易欠你和，分类精度可能不高适用：数字型和标称型数据在只需要两个分类的情况下，我们希望在某个临界分类线下，一侧为正类另一侧为负类，这非常像阶跃函数的性质。但是阶跃函数在非常临近分类线上的数据很容易出现误非类，所以平常往往用与其性质非常类似的sigmoid函数代替其进行分类。其公式如下：对应图形如下：从上图可以看出，sigmoid函数的分界线在y=0.5上，小...
机器学习之logistic回归与分类
我爱智能
08-08 1万+
logistic回归与分类是一种简单的分类算法。在分类的过程中只需要找到一个划分不同类的权重向量即可，对新的数据只需要乘上这个向量并比较就可以得到分类。比如下图的二分类问题： 每个样本点可以看成包含两个特征（x1,x2）,现在需要把他们分开，如果这是训练集，他们本身属于哪一个类是已知的，比如说蓝色的属于0类，红色的属于1类，现在我们想通过这些数据建立一个分类标准可以将他们分开，这样再来了一个不
logistic回归分类
m0_66109479的博客
12-04 93
因此，为了实现Logistic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有的结果值相加，将这个总和代人Sigmoid函数中，进而得到-一个范围在0~1之间的数值。梯度上升法基本的思想是：要找到某函数的 最大值，最好的方法是沿着该函数的梯度方向探寻。逻辑回归的优点：直接对分类的可能性建模，无需事先假设数据分布，避免了假设分布不准确带来的问题，不仅预测出类别，还可得到近似概率预测。我们最经常听到的应该是梯度下降算法，它与这里的梯度上升算法是一样的，只是公式中的加法需要变成减法。
Logistic回归，多类分类
qq_40008456的博客
05-31 2700
1对其他（One-vs-Rest,OvR）： 对每个类别c，训练一个Logistic回归分类器，预测y=c概率 对新的输入x，选择使得最大的类别作为预测（最大后验估计，MAP）： 多项分布 在概率分布中，贝努利（Bernoulli）分布的输出只有两种取值。 Multinoulli分布，或称为范畴分布（categorical distribution），输出有K种取值。 类...
深度学习入门：1.Logistic回归实现分类
最新发布
weixin_43946736的博客
05-13 1283
代码和数据集都有。用Logistic回归进行分类的主要思想：根据现有数据对分类边界线建立回归公式，以此进行分类。
logistic逻辑回归分类算法及应用
xuxu96
04-05 2711
logistic逻辑回归分类算法及应用 3.1 概述 Lineage逻辑回归是一种简单而又效果不错的分类算法。 什么是回归：比如说我们有两类数据，各有50个点组成，当我们把这些点画出来，会有一条线区分这两组数据，我们拟合出这个曲线（因为很有可能是非线性的），就是回归。我们通过大量的数据找出这条线，并拟合出这条线的表达式，再有新数据，我们就以这条线为区分来实现分类。 下图是一个数据集的两组数据，中...
Logistic回归模型与分类
Logistic回归是一种统计分析方法，主要用于处理因变量为分类数据的情况，特别是二分类问题。它的起源在于解决当因变量的概率分布呈现S型曲线（sigmoid函数）时，如何通过线性模型来描述自变量与因变量之间的关系。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ysw！不将就

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值