Spring基础学习,没有理论 都是干货

##学习需要掌握:反射和最简单的MVC架构流程

##对spring有过基础性的理论知识

##按照代码一步步来,30分钟掌握Spring的基本使用

1：先用spring创建一个最简单的对象

首先创建一个对象
package com.itmayiedu.entity;

public class UserEntity {
    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}
创建spring的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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 根据id userentity
    <bean id="userEntity" class="com.itmayiedu.entity.UserEntity" />
</beans>
##根据spring创建文件
package com.itmayiedu.entity.controller;

import com.itmayiedu.entity.UserEntity;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("spring.xml");

        UserEntity userEntity = (UserEntity) application.getBean("userEntity");

        System.out.println(userEntity);

    }

}

2：关于spring的单例等问题

首先如何证明spring单例的

package com.itmayiedu.entity;

public class UserEntity {
    private String name;
    private Integer age;

    public UserEntity() {

        System.out.println("我创建了一个对象");
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}
## 如果地址相同则证明是同一个对象，spring是单例的，package com.itmayiedu.entity.controller;

import com.itmayiedu.entity.UserEntity;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("spring.xml");

        UserEntity userEntity = (UserEntity) application.getBean("userEntity");
        UserEntity userEntity1 = (UserEntity) application.getBean("userEntity");
        System.out.println(userEntity==userEntity1);
        System.out.println(userEntity);

    }

   ## 输出结果：true

}

那么尽然spring是单例（在加载容器的时候便会初始化）如何变成多例的了(也就是更改作用域)？

   <!-- prototype -->
    <bean id="userEntity" class="com.itmayiedu.entity.UserEntity"  scope="prototype"/>

springioc创建对象的方式有哪些

构造函数

工厂创建对象

工厂类 静态工厂

工厂内  非静态工厂

想说一个根据构造函数来创建对象

无参函数刚刚已经说过那,这里主要说一下有参函数,在实体类中我们需要给给他声明一个有参函数

<!-- 无参构造函数 -->
    <bean id="user1" class="com.itmayiedu.entity.UserEntity" scope="prototype" />
    <!-- 有参构造函数 -->
    <bean id="user2" class="com.itmayiedu.entity.UserEntity">
        <constructor-arg name="name" type="java.lang.String"
                         value="张三"></constructor-arg>
        <constructor-arg name="age" type="java.lang.Integer"
                         value="18"></constructor-arg>
    </bean>

这里可以看到无参构造函数的优先于午参构造函数的

首先我们创建一个工厂类

package com.itmayiedu.entity;

import javax.swing.text.html.parser.Entity;

public class ObjectFactory {

    public  UserEntity getInstance(){
        System.out.println();
        return new UserEntity("wwww",23);
    }

    public static UserEntity getStaticInstance(){
        System.out.println();
        return new UserEntity("ggg",66);
    }
}
<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 无参构造函数 -->
    <bean id="user1" class="com.itmayiedu.entity.UserEntity" scope="prototype" />
    <!-- 有参构造函数 -->
    <bean id="user2" class="com.itmayiedu.entity.UserEntity">
        <constructor-arg name="name" type="java.lang.String"
                         value="张三"></constructor-arg>
        <constructor-arg name="age" type="java.lang.Integer"
                         value="18"></constructor-arg>
    </bean>

    <bean id="factory" class="com.itmayiedu.entity.ObjectFactory"></bean>
    <!-- 通过实例工厂方法创建 -->
    <bean id="user3" factory-bean="factory" factory-method="getInstance"></bean>
    <!-- 通过静态工厂方法创建 -->
    <bean id="user4" class="com.itmayiedu.entity.ObjectFactory"
          factory-method="getStaticInstance"></bean>

</beans>

接下来讲讲spring的注入

注入的方式

通过构造函数(上面已经演示过)

通过set方法给对象赋值

p名称空间

自动装配

注解

在这里讲解set方法的注入

### 曾经迪士尼面试官问过一道题,在spring中加入A依赖B 如何进行注入, 当时特别简单的一道题,结果想歪啦.说什么A的实体类有一个B对象进行new,接下来进行正解

这样的话,就完成了抵赖注入.

那么很多人很好奇问啦.为什么叫setter注入.没setter为什么就不行了.其实他底层用了反射setter方法修改属性办法,详情可以看我的过去的博客

https://www.cnblogs.com/itcastwzp/p/10971746.html

P标签注入

<bean id="userService" class="cn.itmayiedu.UserAction" p:userService-ref="userDao"></bean>

这种方式恨简单.但是用的人很少,作为了解就好

Spring注解

如果想使用spring的注解,我们需要在xml中开启注解的权限并且扫描注的范围

<context:component-scan base-package="com.cloudwalk"></context:component-scan>

@Respsitory  他的作用 类似   用于数据层

@Sevice  服务层

@Controller  控制层

作用类似

  <bean id="factory" class="com.itmayiedu.entity.ObjectFactory"></bean>

@Autowired类似

<property name="userDao" ref="userDao"></property>

Spring的AOP

aop可以类似看重复的代码看成切面然后直接引用

首先xml开启aop

  <!--开启AOP注解-->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
@Component
@Aspect
public class Aop {    /** 执行方法执行前**/
    @Before("execution(* com.itmayiedu.entity.controller.UserService.add(..))")
    public void begin(){
        System.out.println("开启事务");
    }    /**执行方法执行后**/
    @After("execution(* com.itmayiedu.entity.controller.UserService.add(..))")
    public void commit(){
        System.out.println("事务提交");
    }
    /**执行方法抛异常**/
    @AfterThrowing("execution(* com.itmayiedu.entity.controller.UserService.add(..))")
    public void error(){
        System.out.println("啊，我有异常啦");
    }
    /**方法运行结束后**/
   @AfterReturning("execution(* com.itmayiedu.entity.controller.UserService.add(..))")
    public void run(){
        System.out.println("运行");
    }
}

然后直接调用即可

这里难点和重点需要学习的是spring aop的表达式的写法 也就是这写aop执行在那些地方有效

具体参考https://www.cnblogs.com/imzhuo/p/5888007.html这位大佬的博客

下面详解如何xml配置aop

首先取消@aspect注解

配置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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.itmayiedu"></context:component-scan>

    <!-- 把切面类注入到容器中-->
    <bean id="aop" class="com.itmayiedu.entity.controller.Aop"> </bean>
        <aop:config>
            <!-- 书写spring aop 拦截表达式-->
            <aop:pointcut id="pf" expression="execution(* com.itmayiedu.entity.controller.UserService.add(..))"></aop:pointcut>
            <!-- 标记一个且表-->
            <aop:aspect ref="aop">
                <!-- 用什么通知,通知用哪个拦截表达式-->
                <aop:before method="begin" pointcut-ref="pf"></aop:before>
                <aop:after method="commit"  pointcut-ref="pf"></aop:after>
            </aop:aspect>
        </aop:config>

</beans>

    运行结果

原文地址：https://www.cnblogs.com/itcastwzp/p/10989649.html

时间： 2024-11-09 14:11:09

Spring基础学习,没有理论 都是干货的相关文章

计算机网络基础学习笔记——理论

历史:第一代:50年代:(多台)终端(terminal)-->计算机(host) 缺点:1.主机负荷重,效率低.  2.终端速率低,线路利用低,费用高. 60年代:通信控制处理机CCP(communication control processer)或FET(front end processor)    集中器.第二代:60年代末:计算机--计算机   1969年,美国国防部国防高级研究计划署(简称ARPA Advanced Research Project Agency)试验.   1972

spring 基础学习笔记

spring 初始理解 1.spring 只是一个框架,是一些相应的 jar包,相当于一个项目的管理者,各种其他框架的中介,项目的监管机构. 2.主要特点是依赖注入DI.面向切面AOP,控制反转IOC 3.核心:加载applicationContext.Xml配置文件,生成applicationContext对象,在配置文件中的bean也会生成各种bean对象,这些bean对象相当于配置文件中的各个类的初始化,或者框架配置, spring通过applicationContext这个对象去管理这些

Spring基础学习(四)&mdash;AOP

一.AOP基础 1.基本需求      需求: 日志功能,在程序执行期间记录发生的活动. ArithmeticCalculate.java public interface ArithmeticCalculate{ public int add(int a,int b); public int sub(int a,int b); public int mul(int a,int b); public int div(int a,int b); } ArithmeticCalculateImpl.

使用JavaConfig方式-Spring 基础学习

在Spring的使用中,大量采用xml方式配置类之间的关系太过于繁琐(个人这么认为),而在学习了Spring4后发下使用JavaConfig方式来配置这些关系会更加的简单明了. 测试环境 1. Apache Maven 2. JDK 1.8 3. IDEA 15 先决条件 1. 使用IDEA创建一个Maven项目 2. 在pom.xml 中引用 <dependency> <groupId>org.springframework</groupId> <artifac

Spring基础学习(二)&mdash;注入参数详解

     在Spring配置文件中,用户不但可以将String.int等字面值注入Bean中,还可以将集合.Map等类型注入Bean中,此外还可以注入配置文件中其他定义的Bean. 一.字面值      (1)可用字符串表示的值,可以通过<value>元素标签或value属性进行注入.      (2)基本数据类型及其封装类.Stting类型都可以采用字面值注入的方式.      (3)若字面值包含特殊字符,可以使用<![CDATA[]]>把字面值包裹起来. <bean id

【Spring基础学习】注解实现自动装配

在IOC容器中学习相关注解(常用) 1. @Autowired a.作用对象:(官网解释) 1. You can apply the @Autowired annotation to constructors: 2.you can also apply the @Autowired annotation to "traditional" setter methods: 3.You can also apply the annotation to methods with arbitra

Spring基础学习笔记-Bean的基础知识

一. Bean的定义,初始化,使用和销毁 二.ref指定依赖的三种模式 三.Bean的五种自动装配模式(autowire) 四.Bean依赖检查的4种模式:配合atuowire使用,dependency-check="" 五.集合的注入方式 六.管理Bean config.xml文件<!--Bean的配置文档--><!--首先定义为XML的方式来存储Bean的配置--><?xml version="1.0" encoding="

Spring基础学习(三)&mdash;详解Bean(下)

一.Bean的生命周期 1.概述      Spring IOC容器可以管理Bean的生命周期,Spring 允许在Bean的生命周期的特定点执行定制的任务.      Spring IOC容器对Bean的生命周期进行管理的过程:      (1)通过构造器或工厂方法创建Bean实例.      (2)为Bean的属性设置值和对其他Bean的引用.      (3)调用Bean的初始化方法.      (4)Bean可以使用了.      (5)当容器关闭时,调用Bean的销毁方法.     

Spring基础学习(五)&mdash;事务管理

一.事务基本认识 1.事务的概述      为了保证数据库中数据的一致性,数据的操作应当是离散的成组的逻辑单元.当它全部完成时,数据的一致性可以保持,而当这个单元中的一部分操作失败,整个事务应当全部视为错误,所有从起始点以后的操作应全部回退到开始状态.      事务的操作: 先定义开始一个事务,然后对数据做修改操作,这时如果提交(commit),这些数据就永久的保存下来,如果回退(rollback),数据库管理系统就放弃所有的修改而回到开始事务的状态.   2.事务的属性 (1)原子性(Atm