git的使用
首先将本项目初始化为本地仓库，然后add到缓存区，在commit到本地仓库，最后push到远程仓库
maven介绍及使用
验证maven是否安装完成
在cmd命令行中输入命令：mvn -v
maven的作用
1.规范目录结构
2.提供了统一的坐标下载jar包的方式
3.提供了一套完整生命周期的命令
maven的相关配置
- 修改本地仓库路径(setting.xml)
<localRepository>D:/software/repository</localRepository>-
配置阿里镜像库，默认仓库:
Maven中央仓库[外网],下载依赖速度会很快
<mirrors>
<mirror>
<id>ali</id>
<name>ali Maven</name>
<mirrorOf>*</mirrorOf>
<url>https://maven.aliyun.com/repository/public/</url>
</mirror>
</mirrors>maven依赖的坐标
当我们用maven导入依赖时，需要提供依赖的坐标，maven会到中央仓库里根据坐标导入相关依赖，这些依赖库在构建过程中会被自动下载并添加到项目的类路径中
通常maven坐标由三部分组成：
1.groupId(工程组名)
2.artifactId(工程名)
3.version(版本)
<dependency>
<groupId>xxxx</groupId>
<artifactId>xxxx</artifactId>
<version>xxxx</version>
</dependency>maven重要网址
-
Maven中央仓库地址（坐标网址）：https://mvnrepository.com/
-
Maven仓库资源地址（资源网址）：https://repo1.maven.org/maven2/
当我们启动项目时，编译器找依赖的顺序：
本地仓库 ---->私服服务器(公司服务器)---->中央仓库
spring框架
spring框架是一个整合资源的框架，整合一切可以整合的资源（例如mybatis这个spring生态之外的框架）
spring是个生态，它包含了很多子框架
springFramework是整个spring生态的核心框架，提供了Ioc和Aop两个核心组件：
Ioc：控制反转的编程思想，反转资源的获取方向，将对象的创建交由框架完成
Ioc容器：Ioc控制反转思想的一种技术实现
创建Ioc容器的两种方式:
//通过注解的方式创建Ioc容器
ApplicationContext context=new AnnotationConfigApplicationContext("包路径");
//通过xml文件的方式创建Ioc容器
ApplicationContext context=new ClassPathxmlConfigApplicationContext("xxx.xml");
//ApplicationContext是Spring框架中的一个核心接口，它继承自BeanFactory接口先谈谈通过注解的方式创建Ioc容器：
这里有一个maven项目，TestUser里创建了Ioc容器
ApplicationContext context = new AnnotationConfigApplicationContext("cn.tedu.spring.example");
在创建Ioc过程中，spring框架会自动扫描该包路径，只要是带有
1.Controller:控制器层,用于接收请求并返回响应; 2.Service:业务层,用于处理业务逻辑; 3.Repository:数据访问层,用于访问数据库; 4.Component:通用注解,用于标记Bean对象;
这些注解的类都会自动为他们创建Bean对象放到Ioc容器中，再通过getBean获取bean对象，就可调用类里面的方法了
User user = context.getBean(User.class);
//run方法是User类的成员方法
user.run();DI依赖注入注解：
@Value
添加在属性和set方法上
1.依赖注入注解[创建Bean对象过程中给属性赋值];
2.基本类型数据注入;
@Component
public class UserDao {
/*
Value注解：
1.依赖注入注解[创建Bean对象过程中给属性赋值];
2.基本类型数据注入;
*/
@Value("jdbc:mysql://localhost:3306/tedu")
private String dbUrl;
@Value("root")
private String username;
@Value("root")
private String password;
@Override
public String toString() {
return "UserDao{" +
"dbUrl='" + dbUrl + '\'' +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}此类上有component注解，在创建Ioc容器时会创建一个名为userDao的bean对象
/**
* 测试类
*/
public class TestUserDao {
public static void main(String[] args) {
/*
1.创建Spring Bean对象,并存入IoC容器中[ApplicationContext接口];
2.从IoC容器中获取Spring Bean对象[getBean(类型.class)];
3.打印测试;
*/
ApplicationContext context = new AnnotationConfigApplicationContext("cn.tedu.spring.di");
UserDao userDao = context.getBean(UserDao.class);
System.out.println(userDao);
//打印拼接属性值
}
}@Autowired注解
自动装配注解;
1.作用：注入对象类型或者接口类型的数据;
2.添加位置:
2.1 添加在属性上;
2.2 添加在set方法上;
2.3 添加在构造方法上;
这里有一个UserDao
public class UserDao {
/*
Value注解：
1.依赖注入注解[创建Bean对象过程中给属性赋值];
2.基本类型数据注入;
*/
@Value("jdbc:mysql://localhost:3306/tedu")
private String dbUrl;
@Value("root")
private String username;
@Value("root")
private String password;
@Override
public String toString() {
return "UserDao{" +
"dbUrl='" + dbUrl + '\'' +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}在UserService类中,注入UserDao对象
@Service
public class UserService {
@Value("Lucy")
private String username;
@Autowired
private UserDao userDao;
自动找到UserDao这个类的bean对象并自动注入到这里来
//@Value("Tom")
public void setUsername(String username) {
this.username = username;
}
//@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
//@Autowired
public UserService(UserDao userDao) {
this.userDao = userDao;
}
@Override
public String toString() {
return "UserService{" +
"username='" + username + '\'' +
", userDao=" + userDao +
'}';
}
}@Qualifier
当一个接口有多个实现类时，会抛出NoUniqueBeanDefinitionException异常, 可以通过 @Qualifier(value="Bean对象名称") 指定需要注入的对象;
@Repository
public class UserCache {
/*
手动指定需要注入的Bean对象
1.IoC容器中Spring Bean对象的名称;
*/
@Autowired
@Qualifier(value = "a")
private Cache cache;
}@Repository(value = "a")
public class CacheImpl1 implements Cache{
}@Resource
Resource: 依赖注入注解,注入对象或者接口类型的数据;
装配机制：
- 根据IoC容器中,Spring Bean对象的名称进行装配[name参数];
- 未指定名称[name参数],把属性名作为Bean对象名称进行装配;
- 属性名和Bean对象名称也不一致,则根据类型进行装配;
@Autowired和@Resource注解的区别？
1.Autowired是Spring Framework注解,Resource是JDK的标准注解;
2.装配机制不同
2.1 Autowired注解根据类型进行装配;
2.2 Resource注解
- 根据Bean对象名称进行装配;
- 未指定名称,则使用属性名作为名称进行装配;
- 属性名和Bean对象名称也不一致,则根据类型进行装配;
- 根据类型装配失败,抛出异常:NoUniqueBeanDefinitionException;
@Scope
单例模式
@Scope(value = "singleton")
@Component
public class Order {
}
ApplicationContext context = new AnnotationConfigApplicationContext("cn.tedu.spring.scope");
// 第1次获取
Order order1 = context.getBean(Order.class);
System.out.println(order1);
// 第2次获取
Order order2 = context.getBean(Order.class);
System.out.println(order2);
//cn.tedu.spring.scope.Order@22eeefeb
//cn.tedu.spring.scope.Order@22eeefeb多例模式
@Scope(value = "prototype")
@Component
public class Order {
}ApplicationContext context = new AnnotationConfigApplicationContext("cn.tedu.spring.scope");
// 第1次获取
Order order1 = context.getBean(Order.class);
System.out.println(order1);
// 第2次获取
Order order2 = context.getBean(Order.class);
System.out.println(order2);
//cn.tedu.spring.scope.Order@22eeefeb
//cn.tedu.spring.scope.Order@17d0685f@Configuration
@ComponentScan
/**
Configuration注解: 当前类为配置类,Spring会自动加载此类;
ComponentScan注解:
1.自动扫描注解,指定包扫描的路径;
2.自动扫描该包以及该包的子孙包中的所有的类,为其创建Spring Bean对象;
*/
@Configuration
@ComponentScan("cn.tedu.spring")
public class SpringConfig {
}不用在给每个类上添加那4个注解生命bean对象了,Spring 会在指定的包及其子包下扫描所有添加 @Component（或 @Service、@Controller、@Repository 等）注解的类，把这些类注册为 Spring Bean，并纳入 Spring 容器进行管理。
@propertySource注解
引入外部属性文件
@PropertySource("classpath:application.properties")
@Component
public class Database {
@Value("${spring.datasource.url}")
private String url;
@Value("${spring.datasource.username}")
private String username;
@Value("${spring.datasource.password}")
private String password;
@Override
public String toString() {
return "Database{" +
"url='" + url + '\'' +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
引入外部文件的步骤
1.在resource下创建application.properties文件
2.在需要引入外部文件的类上添加注解@PropertySource注解
3.依赖注入时，获取具体外部文件的配置项#{spring.datasource.username}
@PropertySource("classpath:application.properties")
@Component
public class Database {
@Value("${spring.datasource.url}")
private String url;
@Value("${spring.datasource.username}")
private String username;
@Value("${spring.datasource.password}")
private String password;
@Override
public String toString() {
return "Database{" +
"url='" + url + '\'' +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}public class TestDatabase {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext("cn.tedu.spring.file");
Database database = context.getBean(Database.class);
System.out.println("database = " + database);
}
}
//database = Database{url='jdbc:mysql://localhost:3306/tedu', username='root', //password='root'}bean对象生命周期
1.实例化阶段（bean对象创建）
在这个阶段中，IoC容器会创建一个Bean的实例，并为其分配空间。这个过程可以通过 构造方法 完成。
2.属性赋值阶段(依赖注入)
在实例化完Bean之后，容器会把Bean中的属性值注入到Bean中，这个过程可以通过 set方法 完成。
3.初始化阶段（bean对象初始化）
(可以人为干预)
@postConstruct注解在属性注入完成后，容器会对Bean进行一些初始化操作；
4.使用阶段(开发者使用)
初始化完成后，Bean就可以被容器使用了
5.销毁阶段
(可以人为干预,例如释放数据库资源)
@preDestroy注解容器在关闭时会对所有的Bean进行销毁操作，释放资源。
@Component
public class Life {
private String meaning;
public Life() {
System.out.println("1:实例化阶段[调用无参构造方法]");
}
@Value("世界那么大,我想去看看")
public void setMeaning(String meaning) {
this.meaning = meaning;
System.out.println("2:属性赋值[set方法]");
}
@PostConstruct
public void init(){
System.out.println("3:生命周期初始化方法");
}
@PreDestroy
public void destroy(){
System.out.println("5.生命周期销毁方法");
}
}public class TestLife {
public static void main(String[] args) {
// 使用AnnotationConfigApplicationContext
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("cn.tedu.spring.life");
Life life = context.getBean(Life.class);
System.out.println("4:开发者使用阶段");
// 关闭IoC容器
context.close();
}
}
//1:实例化阶段[调用无参构造方法]
//2:属性赋值[set方法]
//3:生命周期初始化方法
//4:开发者使用阶段
//5.生命周期销毁方法
扫一扫
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
