Spring学习笔记

Spring

引入依赖

junit为测试框架

可以在方法上标注@Test进行直接的测试

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.15</version>
        </dependency>
 
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>
    </dependencies>

简单的小程序

配置好配置文件

在resource创建spirng的配置文件 applicationContext.xml

然后引入实现类的对象

prototype表示有多例 在执行getBean对象时创建

singleton表示一例 在spring文件配置导入时创建

id为 app.getBean时索引的

<bean id="userDao" class="com.spring.dao.Impl.UserDaoImpl" scope="prototype"></bean>

在main文件里进行创建spring容器

  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

然后通过容器的调取来获取实现类对象，挺类似于JDBC操作中的会话工厂

 UserDao userDao = (UserDao) app.getBean("userDao");

通过容器的存取，统一将类的API放入容器中，需要的时候通过spring容器调取，避免了大量的重复的对dao的先申明创建。

生命周期配置

默认先调用无参构造

spring对象创建时 要强转为功能更为强大的实现类

Bean实例化的三种方式

无参构造方法

通过配置文件映射对应的类

scope表示创建的生命周期

<bean id="userDao" class="com.spring.dao.Impl.UserDaoImpl" scope="singleton"></bean>

工厂静态方法

创建静态工厂的类，创建返回应该实体对象的静态获取方法

然后通过配置文件配置Bean

    <bean id="userDao" class="com.spring.factory.StaticFactory" factory-method="getUserDao"></bean>
 

class 指定对应的静态工厂类 ， factory-method 指定对应id的静态方法

工厂实例方法

因为不是静态方法，所以一般的做法是需要先创建工厂的实体类，然后通过工厂的实体类来调用其中的方法

  <bean id="factory" class="com.spring.factory.DynamicFactory"></bean>
先创建了工厂的实体对象
然后再通过工厂的实体化对象来映射其中的方法
<bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>

依赖注入

通过Set方法实现注入

普通property标签

在对应的需要调用其他类的bean中创建set方法

<bean id="userDao" class="com.spring.dao.Impl.UserDaoImpl" scope="singleton"></bean>
<bean id="userService" class="....">
	<property name="userDao" ref="userDao"></property>
</bean>
name是set方法后面的名称， 也就是属性名
然后ref是上面已经创建好引入的Bean
其实质是将service中的setUserDao方法注入，而依赖注入可以自动配置，将上面的Bean的内容通过有参构造自动注入到userService ， 而不需要自己去通过有参构造该方法
也就是说Service 依赖UserDao的注入

P命名空间

通过构造方法实现注入

<bean id="userService" class="..." >
	<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
第一个name是构造内部的参数名 ref是容器中引入的bean的id名

注入类型

普通数据类型

<bean id="userDao" class="com.spring.dao.Impl.UserDaoImpl" >
	<property name="username" value="zhangsan"></property>
        
</bean>
 

集合数据类型

<bean id="userDao" class="...">
    <!-- 集合容器注入 -->
	<proerty name="strList">
    	<list>
        	<value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </proerty>
    
       <!-- map容器注入 -->
    <property name="usrMap">
    	<map>
        	<entry key="user1" value-ref="user1"> </entry>
            <entry key="user2" value-ref="user2"> </entry>
            <!-- key代表键值对的索引，后面的表示索引的bean对象 -->
        </map>
    </property>
    <!-- 配置类注入 -->
    <property name="properties">
    	<pros>
        	<prop key="p1">ppp1</prop>
            <prop key="p2">ppp2</prop>
            <prop key="p3">ppp3</prop>
        </pros>
    </property>
    
</bean>

import 引入其他配置文件

<import resource="xxxx.xml"></import>

Spring的重点配置-小结

Spring相关API

ApplicationContext

实用的Bean工厂Application Context Application Context的中文意思是“应用前后关系”，它继承自BeanFactory接口，除了包含BeanFactory的所有功能之外，在国际化支持、资源访问（如URL和文件）、事件传播等方面进行了良好的支持，被推荐为JavaEE应用之首选，可应用在Java APP与Java Web中。——词条

三个实现类

• ClassPathXmlApplicationContext //根路径

• FileSystemXmlApplicationContext // 绝对路径

• AnnotationConfigApplicationContext //注解配置容器对象时，需要使用此类来创建spring容器，用来读取注解

GetBean方法

两种方式每一个是通过id来获取，另一个是通过.class来获取

前者需要对获取的Bean进行强制类型转换

如果Bean注解中有多个，应该通过id来获取，如果只有一个可以通过类来获取

Spring配置数据源

组件扫描

引入context命名空间

<?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/contexthttp://www.springframework.org/schema/context/spring-context.xsd">
 
</bean>
 

context常用命名空间的标签及其属性

<context:property-placeholder />:加载外部的.properties文件到spring容器当中,可以通过spel,即${}获取到值,例如配置数据库连接参数
 
<context:property-placeholder location="classpath:jdbc.properties" />
 
 
<context:component-scan />:配置组件扫描,可以扫描指定包下的注解
 
<context:component-scan base-package="com.app" />

注解开发

在bean上

@Component("beanId")

自动注入

//在定义的变量上
@Autowired
@Qualifier("前面定义的需要注入的bean的Id")

仅有Autowired，会自动找同类型的bean，有多个bean没法注入

xml文件是通过set方式注入的，但是将下面的set方法删除，也可以通过反射机制暴力注入

@Resourse(name="beanId")//相当于@Qualifier + @Autowired

@Value("")
private String d;
//普通类型注入
 
@Value(${})//在配置文件加载好外部配置文件的时候

生命周期

@Scope("Singleton")
@Scope("prototype")
 

新注解

核心配置类——注解

@Configuration
@ConponentScan("")//包扫描
@propertySource("")//加载配置文件
public class SpringConfiguration(){
    
    @Value("${}")
    String
    @Bean("")
    ...
}

更改核心配置类

//ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//引入xml配置类文件
 
//引入类核心配置类
ClassPathXmlApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class)
 

Spring整合Mybaits

新加注解

<dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
         </dependency>

整合mybaits的Bean类

AOP

导入依赖

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

绑定切入点

通知Spring执行AOP

@EnableAspectJatuoproxy

切入点描述

Spring事务

JDBC的事务管理器

SpringMVC

Spring boot

引入maven依赖

 <!--  父工程  -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.4</version>
    </parent>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

父工程中 包含了相对应用场景的依赖

主程序固定模式

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
/**
 * @SpringBootApplication: 注解这是一个springboot应用
 */
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}
 

application.properties

springboot的依赖文件，可以通过更改依赖的属性来配置springboot

属性参考文档

将项目直接打包为可执行的jar包

maven配置

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
 

执行jar包的关闭

该方法为通过springboot的组件在网页中嵌入中进行关闭的操作 下面的方法为Linux命令行中操作 直接杀进程 kill -9 [PID]

同时Windows中，可以cmd - taskmgr - 找到相应的java-jar进程关闭

参考地址

依赖

<dependency>
 
    <groupId>org.springframework.boot</groupId>
 
    <artifactId>spring-boot-starter-actuator</artifactId>
 
</dependency>

application.properties中添加：

#启用shutdown
 
endpoints.shutdown.enabled=true
#禁用密码验证
 
endpoints.shutdown.sensitive=false

然后可以调用 http://localhost:8080/shutdown 进行关闭，其中localhost:8080 需要替换为自己实际的地址和端口

如果要配置路径，需要在application.properties中添加

management.context-path=/manage

则关闭命令http://localhost:8080//manage/shutdown

如果在关闭时需要安全验证，则在pom.xml文件中添加

<dependency>
 
     <groupId>org.springframework.boot</groupId>
 
     <artifactId>spring-boot-starter-security</artifactId>
 
</dependency>

application.properties中添加：

#开启shutdown的安全验证
 
endpoints.shutdown.sensitive=true
#验证用户名
 
security.user.name=admin
#验证密码
 
security.user.password=admin
#角色
 
management.security.role=SUPERUSER
# 指定端口
 
management.port=8081
# 指定地址
 
management.address=127.0.0.1

or

启动：java -jar 命令的最后添加 "&"，后台运行java程序；

　　关闭：”fg jobnum“命令将后台程序转到前台执行，然后“CTRL+C组合健“关闭；

Linux下jar包的启动

java -jar platform-scm-v108.jar --spring.profiles.active=product --server.port=8080 & //简单启动

nohup java -jar platform-scm-v108.jar --spring.profiles.active=product --server.port=8080 &  //不挂断后台启动

nohup java -jar platform-scm-v108.jar --server.port=8080 > server.log 2>&1 & //不挂断后台启动且重定向日志

停止jar包

ps -ef | grep platform-scm-v108.jar
 
# 找到对应的进程然后杀掉
 
kill -9 进程号

kill -9 `ps -ef | grep platform-scm-v108.jar | grep -v 'grep' `
说明：两次使用管道，排除其他进程，直接杀掉相应的进程。

另一种停止

ps -ef | grep "java -jar"
kill -9 xx

springboot的包扫描

@SpringBootApplication(scanBasePackages="从根目录下的包")

@Conditional - 条件装配 符合条件时，才装配进该组件

@ImportResouce("classpath:xx.xml")

导入spring配置文件

自动配置绑定

1.@ConfigurationProperties(prefix="")

省去了用正则表达式读取截取xml文件

只有在容器中的组件才能用注解的方式用springboot

所以需要在前面加个@Component自动注册Bean组件

2.@EnableConfigurationProperties(xx.class)

日志记录

private static final Logger log = LoggerFactory.getLogger(当前类名称.class)
or
private Logger logger = LoggerFactory.getLogger(this.getClass());
or
直接用lombok 类上加上注解@Slf4j
 
log.dubug("")
log.info("")
log.warn("")
log.error("")
 
配置.yml
 
logging:
  level:
  	root:debug/info/warn/error # 信息从多到低
  	com.xx: dubug #对某个包设置debug级别
  	enbank: debug #对某个组设置级别
  group:
  	ebank: com.xxx,com.xxx #分组1
	#日志格式
	pattern:  	
  		console: "%d %clr(%5p){}" #%d时间 %clr彩色{color}指定的颜色 %5p占位5的信息级别  %t线程名 %c 类名 %n换行
  	#分日志文件
  	file:
  		name: server.log
  	logback:
  		rollingpolicy:
  			max-file-size: 4KB
  			file-name-pattern: server.%d{yyyy-MM-dd}.%i.log
  	

热部署

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>test</scope>
 </dependency>
        

加了依赖之后

构建->构建项目 or Ctrl+F9

Shiro

Map<String, String> filterMap = new LinkedHashMap<>();
filterMap.put("/user/add","authc");  ///认证了才能用