Spring-day01

最新推荐文章于 2024-05-03 13:13:36 发布

m0_46611616

最新推荐文章于 2024-05-03 13:13:36 发布

阅读量128

点赞数

文章标签： spring github java

本文链接：https://blog.csdn.net/m0_46611616/article/details/126393494

版权

一、Git的基本使用

1、创建仓库

在注册完成并成功登录 Gitee 账号后，用户可以开始创建自己的第一个仓库。

1、通过网站右上角的「+」号，选择「新建仓库」，进入新建仓库页面

新建仓库

2、在新建仓库页面填写仓库信息。仓库相关概念说明如下：
仓库名称：仓库的名称，用于仓库命名
归属：仓库归属账户，可以是个人账号/组织/企业中的一种，创建成功后该账户默认为仓库的拥有者（管理员）
路径：仓库的git访问路径，由用户个性地址+仓库路径名称组成。创建仓库后用户将通过该路径访问仓库。
仓库介绍：仓库的简单介绍
是否开源：设置仓库是否为公开仓库，公开仓库对所有人可见，私有仓库仅限仓库成员可见。
选择语言：仓库主要开发用的编程语言
添加.gitignore：系统默认提供的git忽略提交的文件模板，设置.gitignore后将默认忽略指定目录/文件到仓库
添加开源许可证：如果仓库为公开仓库，可以添加设置仓库的开源协议，作为对当前项目仓库和衍生项目仓库许可约束，开源许可证决定了该开源项目是否对商业友好。
Readme：项目仓库自述文档，通常包含有软件的描述或使用的注意事项。
使用\**\*模板文件初始化仓库：使用Issue或Pull Request文件模板初始化仓库

屏幕截图.png

3、点击「创建」，即可在Gitee上创建你的第一个仓库。

2、提交第一行代码

在创建完仓库之后，用户可以通过如下方式，可以向仓库提交第一行代码。

此处我们以用户账号下命名为 HelloGitee 的仓库为例。对应的仓库地址为：https://gitee.com/用户个性地址/HelloGitee.git，在实际实践中，你可以将用户个性地址替换为自己的地址。

方法1、先将仓库clone到本地，修改后再push到 Gitee 的仓库

$ git clone https://gitee.com/用户个性地址/HelloGitee.git #将远程仓库克隆到本地

在克隆过程中，如果仓库是一个私有仓库，将会要求用户输入 Gitee 的账号和密码。按照提示输入即可。

当然，用户也可以通过配置本地的git配置信息，执行git config命令预先配置好相关的用户信息，配置执行如下：

$ git config --global user.name "你的名字或昵称"
$ git config --global user.email "你的邮箱"

在 Gitee 平台中，强烈建议您在【设置-多邮箱管理】中的“提交邮箱”与上面配置信息中的邮箱地址保持一致，这样平台就能及时地统计您在平台中提交代码的贡献了。

修改代码后，在仓库目录下执行下面命令

$ git add . #将当前目录所有文件添加到git暂存区
$ git commit -m "my first commit" #提交并备注提交信息
$ git push origin master #将本地提交推送到远程仓库

方法2、本地初始化一个仓库，设置远程仓库地址后再做push

和方法1的差别，在于先创建仓库。

$ git init 
$ git remote add origin https://gitee.com/用户个性地址/HelloGitee.git

这样就完成了版本的一次初始化。
接下去，进入你已经初始化好的或者克隆仓库的目录,然后执行：

$ git pull origin master

修改/添加文件，否则与原文件相比就没有变动。

$ git add .
$ git commit -m "第一次提交"
$ git push origin master

然后如果需要账号密码的话就输入账号密码，这样就完成了一次提交。此时，你可以在你的个人面板、仓库主页查看到你的提交记录。

在新建仓库时，如果在 Gitee 平台仓库上已经存在 readme 或其他文件，在提交时可能会存在冲突，这时用户需要选择的是保留线上的文件或者舍弃线上的文件，如果您舍弃线上的文件，则在推送时选择强制推送，强制推送需要执行下面的命令(默认不推荐该行为)：

$ git push origin master -f

如果您选择保留线上的 readme 文件,则需要先执行：

$ git pull origin master

3、安装客户端

4、初始化环境

让当前文件夹，被git所管理起来！

命令行：在当前文件夹下打开git的黑窗口！

git init

使用TortoiseGit可视化菜单工具来操作，Git在这里创建版本库！

5、连接远程

复制远程项目仓库的url(自己的仓库)！

在本地设置中，配置远程地址！

点击添加，然后点击确定。

如果在第一次拉取的时候，本地有文件，一定要pull拉取后，选择合并历史相关版本。

另外一个操作是，直接克隆项目！

6、常规操作

先写代码，当代码写完后！
存档：git commit；提交代码！记得一定要写message消息：日志信息。
推送：git push；推送代码到远端。
如果，远端有别人推送的东西后，我无法直接推送我的内容，必须先拉取: git pull；拉取！把远端的内容拉取到本地。
最后在重新push，推送就ok；

二、面向对象

思想：

Java语言是面向对象，就是强调对象，比如说我们要做一个大型的项目，但是呢，做这个项目需要划分几个功能块（方法），这几个功能块组合在一起就形成了这个项目，但是，我们换了一种思想，我们找一个对象，该对象具备这几个功能，那我们只需要重点关注这一个对象就可以了。

封装、继承、多态、抽象！

1、封装

提高代码复用性！！！！

隐藏具体实现、开放少量接口！

访问修饰符：隐藏private！

类似：现实中的空调、汽车、电脑。

2、继承

扩展！

开闭原则：对扩展开放，对修改关闭。

可以写子类扩展父类，但是不能去直接修改父类。类似：jdk版本向下兼容。屎山！

3、多态

一个物种的多种表现形态。

类似：人美国人中国人日本小矮子！

4、抽象

对大家都具有的具体行为的提取

明明有了抽象，为什么还需要接口？

java是单继承！但是可以实现多个接口！接口中都是抽象方法，具体抽象功能（规范）！

企业中比较常见的行为：面向接口开发！

三、IO

输入流（Inputstream）：磁盘到内存。

输出流（Outputstream）：内存到磁盘。

序列化：对象转换成字节流(字节码文件)！一堆各种属性方法，把它们压缩到一个二进制文件中，方便存储和传输。

类似：搬家！呼叫货拉拉！自己封装排列家具和物品的行为叫做序列化！

反序列化：

类似：从货拉拉上卸货，并拆开布置到新家的对应位置上。

四、没有Spring的时候我们该怎么实现Spring

1. 耦合度

非它不可！没有它就不能进行下一步任务操作

强耦合代码：

class A{}public class B{    //非A类不可，否则无法创建B类    public B(A a){    }}

解决方案：使用接口解耦！

抛出一个问题：编译期间不依赖，运行期间才依赖！多态如何解决的这个？接口回调方式解耦！

2. 演示demo

定义一个人类接口，提供一个方法eat，2个实现类，Chinese，American！

写一个测试类，用多态的手段进行调用。

口诀：父类引用指向子类实现!

测试类：

package com.woniuxy.test;
import com.woniuxy.entity.Person;
import com.woniuxy.entity.impl.American;
import com.woniuxy.entity.impl.Chinese;

public class Test {
    public static void main(String[] args) {

        Person person = new American();
        person.eat();
    }
}

3. 使用反射解耦

3.1 反射创建对象的方法

Class.forName(“全限定类名”);

类名.class

对象.getClass()

3.2 测试类使用配置文件解耦

package com.woniuxy.test;
import com.woniuxy.entity.Person;
import java.io.InputStream;
import java.util.Properties;

public class Test1 {
    public static void main(String[] args) throws Exception {
        //平时写代码的时候，不可能只有一个地方new这个对象！
        //现在需要改变的只有一个东西，字符串！这个字符串可以从配置文件中读取！
        //怎么读取配置文件？
        Properties properties = new Properties();
        //需要一个输入流
        InputStream inputStream = Test1.class.getResourceAsStream("person.properties");
        //读取输入流，转换成对象信息，并封装到Properties对象中
        properties.load(inputStream);
        //properties这个对象中，有没有办法获取到文件流中的内容？通过key获取全限定类名
        String str = properties.getProperty("person");
        Person person = (Person) Class.forName(str).newInstance();
        person.eat();
    }
}

这种写法会面临一个问题：

就是每个测试类，都要写一遍这个读取配置文件的方法！

解决方案：利用封装思想！封装为一个工具类，在java中，某个工具类是用来创建对象的，那么这个工具类，通常使用的是工厂设计模式！通过工厂制造对象！

4.工厂模式解耦

spring底层，就是使用的工厂模式创建对象！

4.1 第一个工厂模式

package com.woniuxy.factorys;
import com.woniuxy.entity.Person;
import com.woniuxy.test.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PersonFactory {
    
    //直接通过配置文件创建对象，不手动指定具体对象是谁！
    public static Person makePerson(){
        //怎么读取配置文件？
        Properties properties = new Properties();
        //需要一个输入流
        InputStream inputStream = Test.class.getResourceAsStream("../test/person.properties");
        Person person = null;
        try {
            properties.load(inputStream);
            //properties这个对象中，有没有办法获取到文件流中的内容？通过key获取全限定类名
            String str = properties.getProperty("person");
            person = (Person) Class.forName(str).newInstance();
        } catch (IOException | ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return person;
    }
}

解决了代码重复性过高的问题！

但是，同时又出现了一个问题就是它只能制造同一个类的对象，无法全部创建出来，不能想用哪个自己去用！

4.2 模拟spring底层的工厂

读取配置文件的时候不创建对象，在用的时候创建！

package com.woniuxy.factorys;
import com.woniuxy.entity.Person;
import com.woniuxy.test.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MyBeanFactory {
    //在读取配置文件后，我需要存储文件中的全限定类名
    private static Map<String,String> map = new HashMap();
  
    //
    static{
        //怎么读取配置文件？
        Properties properties = new Properties();
        //需要一个输入流
        InputStream inputStream = Test.class.getResourceAsStream("../test/person.properties");
        Person person = null;
        try {
            properties.load(inputStream);
            //获取了所有的key？还是value
            Set<String> keys = properties.stringPropertyNames();
            for (String name:keys) {
                String property = properties.getProperty(name);
                map.put(name,property);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public  Object getBean(String name){
        //只是获取的全限定类名
        String value = map.get(name);
        try {
            return Class.forName(value).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

对象是单例(singleton)还是原型(prototype)？

原型模式，每次都会基于原型(class)创建新的对象！

nstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}


**对象是单例(singleton)还是原型(prototype)？**

> 原型模式，每次都会基于原型(class)创建新的对象！