IT行业现状及未来发展趋势

一介俗人

IT行业过去五年经历了年28%的增长速度，是同期国家GDP增长速度的三倍，对GDP增长的拉动作用已进一步增强，对我国国民经济增长的贡献率不断提高。

2020年，在云科技、开放资源、移动、大数据和安全领域，科技人才需求量是最大的。同时，科技在任何行业的需求都在增加。医疗保健、金融和制造业的专业人士在各自行业中对科技人才的需求量越来越大。

随着网络信息技术的迅速发展和普及，对IT技能人才的需求正在相当长的时间内出现供不应求的局面，因此IT行业的发展前景将是十分广阔的。

根据报告数据显示，有47.2%的高薪岗位来自千人以上的大公司，岗位以产品、研发、和设计三大块构成，Java工程师招聘数量最多，充分说明了IT行业对人才的需求，而且能开出更高的薪资。

在此时代背景下的IT行业，正在以超强的发展势头吸引着人才的涌入，成为发展前景好，薪资水平高的高薪行业之一，连续四年据行业榜首！

纵观现在IT行业大趋势来看，未来十年IT行业仍会处于高速发展的态势，IT行业对人才的需求量也变得越来越大。

随着网络信息技术的迅速发展和普及，对IT技能人才的需求正在相当长的时间内出现供不应求的局面，因此IT行业的发展前景将是十分广阔的。

1、maven 下载

官网：Welcome to The Apache Software Foundation!

2、解压maven.zip文件

2.1 修改setting.xml 文件

conf 》setting.xml 文件

3、idea 创建简单 maven项目

File 》new 》Project

选择 maven 项目

4、maven 项目结构

src/main/java : 用来写我们的java 源代码

src/main/resources：用来存放配置文件，比如，applicationContext.xml

src/test/java：用来写测试代码

5、添加spring核心容器依赖

其实所谓的依赖，就是我们之前去网上下载jar包，然后导入项目，现在我们通过maven去添加依赖的方式，去下载相应的jar包

spring 核心容器需要的jar包：

beans、core、aop、express

5.1、pom.xml

dependencies : 表示将我们需要添加的依赖全部放到该标签里

dependency：表示我们要添加的依赖

groupId：表示我们添加依赖的项目所在的包

artifactId：表示我们添加的依赖的项目名称

version：表示我们添加的依赖的项目的版本号

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.2.18.RELEASE</version>

</dependency>

6、创建applicationContext.xml文件

在 src 》 main 》新建new 》directory

文件名：resources 资源文件夹，用来存放我们的配置信息

6.1 、创建applicationContext.xml

7、Demo

7.1、项目结构

dao: 放我们操作数据库的接口

daoImpl：这个包下面的类去实现 dao层的接口

service：业务逻辑层，也是放的接口

serviceImpl：这个包下面的类去实现 service层的接口

entity：放我们的实体类

7.2、创建一个学生类【Student】

package org.wuxin.ssm.entity;

public class Student {

// 属性

private String sno;// 学号

private String name;

private int age;

private char sex;

private String sdept;// 系别

// 无参构造器

public Student() {

}

// 有参构造器

public Student(String sno, String name, int age, char sex, String sdept) {

this.sno = sno;

this.name = name;

this.age = age;

this.sex = sex;

this.sdept = sdept;

}

// setter 方法

public void setSno(String sno) {

this.sno = sno;

}

public void setName(String name) {

this.name = name;

}

public void setAge(int age) {

this.age = age;

}

public void setSex(char sex) {

this.sex = sex;

}

public void setSdept(String sdept) {

this.sdept = sdept;

}

// toString方法

@Override

public String toString() {

return "Student{" +

"sno='" + sno + '\'' +

", name='" + name + '\'' +

", age=" + age +

", sex=" + sex +

", sdept='" + sdept + '\'' +

'}';

}

7.3、创建一个Test类

package org.wuxin.ssm;

import org.wuxin.ssm.entity.Student;

public class Test {

public static void main(String[] args) {

/* 我们之前实例化一个类的时候：

操作：通过关键词 new 去创建一个类的实例对象

new 的时候，其实就是通过类的构造方法去实例化对象

eg： new Student(); 这样通过无参构造方法，创建的实例对象的属性都没有赋值

new Student(参数列表);

思考：这样去做，是不是，增加了 Test 与 Student 这个两个类的耦合度【关联程度】

spring 容器：减低类与类之间的耦合度，其实我们可以这样理解：所谓的减低耦合度，就是让类的实例化过程交给spring 容器操作

这种思想叫spring 控制反转（ioc）的思想，

我们这样去理解：本来 Student类的实例化操作，应该在Test 类中通过关键词new完成，

现在实例化Student类的操作，不由Test 类中操作，而是通过spring容器操作

Student s = new Student();

Student s_1 = new Student("1001","jason",20,'男',"计算机科学与技术系");

}

7.4、bean

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns=" http://www. springframework.org/sch ema/beans "

xmlns:xsi=" http://www. w3.org/2001/XMLSchema-i nstance "

xsi:schemaLocation=" http://www. springframework.org/sch ema/beans http://www. springframework.org/sch ema/beans/spring-beans.xsd ">

<!--bean 标签其实就是代表一个对应的类

类：Student 类

id：标识我们的类的实例对象

class：表示我们类的路径【包+类名】

包：org.wuxin.ssm.entity

类名：Student

value：org.wuxin.ssm.entity.Student

-->

<!--构造方法注入

其实我们可以这样理解：通过有参的构造方法，去给Student类的实例对象属性赋值

-->

<!--constructor

name：表示我们有参构造方法中参数

value：表示我们有参构造方法中参数对应的值

ref：表示类与类之间引用

index：表示我们有参构造方法中的参数下标，从0开始，一般也不写这个属性

type：表示的是我们value值得数据类型,一般不写这个属性。

-->

<constructor-arg name="sno" value="1002" index="0" type="java.lang.String" ></constructor-arg>

<constructor-arg name="name" value="smith" type="java.lang.String" index="1"></constructor-arg>

<constructor-arg name="age" value="21" type="int" index="2"></constructor-arg>

<constructor-arg name="sex" value="女" type="char" index="3"></constructor-arg>

<constructor-arg name="sdept" value="软件工程" type="java.lang.String" index="4"></constructor-arg>

</bean>

</beans>

7.5、初始化spring容器

// 初始化spring 容器，并加载 applicationContext.xml 文件

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

7.6、获取bean

// 初始化spring 容器，并加载 applicationContext.xml 文件

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

// 通过 id 值获取bean，其实就是spring容器给我们实例化好的类对象

Student s_2 = (Student)ctx.getBean("student");// 这个就是我们的Student类的实例对象,需要我们数据类型强转

System.out.println(s_2.toString()) ;

7.7、完整Test 测试类代码

package org.wuxin.ssm;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.wuxin.ssm.entity.Student;

public class Test {

public static void main(String[] args) {

/* 我们之前实例化一个类的时候：

操作：通过关键词 new 去创建一个类的实例对象

new 的时候，其实就是通过类的构造方法去实例化对象

eg： new Student(); 这样通过无参构造方法，创建的实例对象的属性都没有赋值

new Student(参数列表);

思考：这样去做，是不是，增加了 Test 与 Student 这个两个类的耦合度【关联程度】

spring 容器：减低类与类之间的耦合度，其实我们可以这样理解：所谓的减低耦合度，就是让类的实例化过程交给spring 容器操作

这种思想叫spring 控制反转（ioc）的思想，

我们这样去理解：本来 Student类的实例化操作，应该在Test 类中通过关键词new完成，

现在实例化Student类的操作，不由Test 类中操作，而是通过spring容器操作

Student s = new Student();

Student s_1 = new Student("1001","jason",20,'男',"计算机科学与技术系");

// 初始化spring 容器，并加载 applicationContext.xml 文件

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

// 通过 id 值获取bean，其实就是spring容器给我们实例化好的类对象

Student s_2 = (Student)ctx.getBean("student");// 这个就是我们的Student类的实例对象,需要我们数据类型强转

System.out.println(s_2.toString()) ;

}

7.8、运行结果

8、案例

8.1、dao层

创建一个接口 Login.class

package org.wuxin.ssm.dao;

public interface Login {

// 用户登录

public boolean login(String username,String password);

}

8.2、daoImpl 层

创建一个类 LoginImpl.class

LoginImpl 实现接口 Login

public class LoginImpl implements Login

重写Login中的抽象方法

package org.wuxin.ssm.daoImpl;

import org.wuxin.ssm.dao.Login;

public class LoginImpl implements Login {

@Override

public boolean login(String username, String password) {

用户名：admin

密码：123456*/

if((username!=null && !"".equals(username)) && (password!=null && !"".equals(password))) {// 用户名和密码不能为空或者null

if("admin".equals(username) && "123456".equals(password)){

// 登录成功

return true;

}else {

// 登录失败

return false;

}

}else {

System.out.println("用户名和者密码不能为空或者null");

return false;

}

8.3、service 层

创建一个接口 LoginService.class

package org.wuxin.ssm.service;

public interface LoginService {

public boolean login(String username,String password);

}

8.4、serviceImpl层

创建一个类 LoginServiceImpl.class 去实现接口 LoginService

package org.wuxin.ssm.serviceImpl;

import org.wuxin.ssm.dao.Login;

import org.wuxin.ssm.service.LoginService;

public class LoginServiceImpl implements LoginService {

@Override

public boolean login(String username, String password)

{

return dao.login(username,password);

}

// set方法

public void setDao(Login dao) {

this.dao = dao;

}

8.5、bean

</bean>

8.6、测试代码

// 初始化spring 容器，并加载 applicationContext.xml 文件

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

// 通过 id 值获取bean，其实就是spring容器给我们实例化好的类对象

LoginServiceImpl l = (LoginServiceImpl) content.getBean("loginServiceImpl");//创建LoginServiceImpl这个类的实例对象

boolean flag = l.login("admin","123456");

if(flag){

System.out.println("success");

}else {

System.out.println("error");

}

8.7、运行结果

9、构造方法注入（参数注入）

9.1、创建一个Student 类

思考：构造方法【constructor】作用？

我们可以这样理解，构造方法就是用来实例化对象用的

实例化对象：其实就是通过关键词 new 类的构造方法

构造方法：有参构造方法：创建出来该类的实例对象属性都有赋值

无参构造方法：创建出来该类的实例对象属性都没有赋值

eg： new Student（）创建一个Student实例对象但是属性没有赋值

new Student（“101”,"jason",'男',20,"计算机科学与技术"）

package sxly.entity;

public class Student {

// 属性

private String sno;

private String sname;

private char sex;

private int age;

private String sdept;// 系别

// 构造方法 constructor

public Student() {

}

public Student(String sno, String sname, char sex, int age, String sdept) {

this.sno = sno;

this.sname = sname;

this.sex = sex;

this.age = age;

this.sdept = sdept;

}

// setter

public void setSno(String sno) {

this.sno = sno;

}

public void setSname(String sname) {

this.sname = sname;

}

public void setSex(char sex) {

this.sex = sex;

}

public void setAge(int age) {

this.age = age;

}

public void setSdept(String sdept) {

this.sdept = sdept;

}

// toString

@Override

public String toString() {

return "Student{" +

"sno='" + sno + '\'' +

", sname='" + sname + '\'' +

", sex=" + sex +

", age=" + age +

", sdept='" + sdept + '\'' +

'}';

}

9.2、之前我们创建Student实例对象操作

创建一个包含主方法的类

package sxly;

public class Test {

public static void main(String[] args) {

}

在该类中通过关键词new 创建实例对象

package sxly;

import sxly.entity.Student;

public class Test {

public static void main(String[] args) {

Student s = new Student();

Student s_1 = new Student("1001","jsaon",'男',20,"信息工程系");

System.out.println(s_1.toString());

}

9.3、Test 与 Student 这两个类关系

Test 类中创建了 Student类的实例对象，从而导致这两个类之间产生了关联，而我们在写代码的时候，应该尽量减低类与类之间的关联程度（耦合度）。

现在我们就可以通过spring框架中一个思想，这个思想叫控制反转（ioc），让类的实例化过程交给spring容器去操作

9.4、spring 容器去实例化类对象

bean ：简单的理解bean其实就是一个实例对象

class：其实就是指我们要实例化哪一个类的路径（包+类名）

eg：包：sxly.entity

类：Student

class=包+类名

sxly.entity.Student

id：标识这个bean对象,一般情况在是类名（首字母小写）

eg：id = student

构造方法注入（参数注入）

name:表示我们通过类的有参构造方法，给哪一个参数进行注入（赋值）

value：name 对应的值

constructor-arg：构造方法注入的标签

<constructor-arg name="sno" value="1002"></constructor-arg>

<constructor-arg name="sname" value="smith"></constructor-arg>

<constructor-arg name="sex" value="女"></constructor-arg>

<constructor-arg name="age" value="20"></constructor-arg>

<constructor-arg name="sdept" value="外语系"></constructor-arg>

</bean>

9.5、测试

package sxly;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import sxly.entity.Student;

public class Test {

public static void main(String[] args) {

/* Student s = new Student();

Student s_1 = new Student("1001","jsaon",'男',20,"信息工程系");

System.out.println(s_1.toString());*/

/*初始化spring容器，并加载applicationContext.xml文件*/

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

/*获取bean ,其实就是获取实例对象*/

Student s_2 = (Student) ctx.getBean("studentId");

System.out.println(s_2.toString());

}

9.6、运行结果

10、Set方法注入

10.1、创建实体类User

package org.wuxin.ssm.entity;

public class User {

// 属性

private String uname;

private char sex;

private long tel;

private String address;

// setter 方法，其实就是给User类中私有化的属性赋值

public void setUname(String uname) {

this.uname = uname;

}

public void setSex(char sex) {

this.sex = sex;

}

public void setTel(long tel) {

this.tel = tel;

}

public void setAddress(String address) {

this.address = address;

}

// toString

@Override

public String toString() {

return "User{" +

"uname='" + uname + '\'' +

", sex=" + sex +

", tel=" + tel +

", address='" + address + '\'' +

'}';

}

10.2、通过spring容器创建User类实例对象

</bean>

10.3、测试

// 初始化spring 容器，并加载 applicationContext.xml 文件

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

User user = (User) content.getBean("user");

System.out.println(user.toString());

10.4、set注入的几个注意事项

实体类中只有有参构造方法，必须也把无参构造方法写出来

验证：

在User类中只添加有参构造方法

public User(String uname, char sex, long tel, String address) {

this.uname = uname;

this.sex = sex;

this.tel = tel;

this.address = address;

}

2.测试

3. 解决方法，加上无参构方法

// 坑——1 ：有参构造方法

public User(String uname, char sex, long tel, String address) {

this.uname = uname;

this.sex = sex;

this.tel = tel;

this.address = address;

}

// 解决坑-1 ：加上无参构造方法

public User() {

}

4.测试

实体类中属性值必须和 set注入的name值一致

11. spring属性注入：p注入方式

1.先在命名空间上引入：p

xmlns:p=" http://www. springframework.org/sch ema/p "

2.使用p命名空间注入值

</bean>

12、spring 集合注入

12.1、创建Address 类

package org.wuxin.ssm.DI;

public class Address {

private String address;

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

12.2 创建Student类

package org.wuxin.ssm.DI;

import java.util.Arrays;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class Student {

private String name;

private Address address;// 地址

// 集合

private String[] books;// 专业课教材，字符串数组["c语言程序设计"，"C++编程"]

private List<String> hobbys;// 爱好

private Map<String,String> card;// 学生卡，水卡：卡号key：持有者value

private Set<String> games;// 游戏

// setter / getter

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Address getAddress() {

return address;

}

public void setAddress(Address address) {

this.address = address;

}

public String[] getBooks() {

return books;

}

public void setBooks(String[] books) {

this.books = books;

}

public List<String> getHobbys() {

return hobbys;

}

public void setHobbys(List<String> hobbys) {

this.hobbys = hobbys;

}

public Map<String, String> getCard() {

return card;

}

public void setCard(Map<String, String> card) {

this.card = card;

}

public Set<String> getGames() {

return games;

}

public void setGames(Set<String> games) {

this.games = games;

}

// toString

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", address=" + address.getAddress() +

", books=" + Arrays.toString(books) +

", hobbys=" + hobbys +

", card=" + card +

", games=" + games +

'}';

}

12.3、bean

<array>

</array>

</property>

<list>

</list>

</property>

<set>

</set>

</property>

<map>

</map>

</property>

</bean>

</bean>

12.4、junit 单元测试

package org.wuxin.ssm;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.wuxin.ssm.DI.Student;

public class Test {

@org.junit.Test

public void test(){

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

Student s = (Student)content.getBean("studentId");// Object Student

System.out.println(s.toString());

}

12.5、运行结果

13、基于注解（Annotation）的Bean装配

13.1、修改spring配beans 文件

<beans xmlns=" http://www. springframework.org/sch ema/beans "

xmlns:xsi=" http://www. w3.org/2001/XMLSchema-i nstance "

xmlns:p=" http://www. springframework.org/sch ema/p "

xmlns:context=" http://www. springframework.org/sch ema/context "

xsi:schemaLocation=" http://www. springframework.org/sch ema/beans

http://www. springframework.org/sch ema/beans/spring-beans.xsd

http://www. springframework.org/sch ema/context

http://www. springframework.org/sch ema/context/spring-context.xsd

13.2、配置spring自动扫描组件

<!--扫描组件

base-package：表示要扫描哪一个包

-->

<context:component-scan base-package="org.wuxin.ssm.annotation"></context:component-scan>

13.3、创建Teacher类

package org.wuxin.ssm.annotation;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Component;

@Component ：把Teacher类加入到spring容器中，并且默认id值为teacher

等价于

@Value("1001")

等价于

@Value("jason")

等价于

* */

@Component

public class Teacher {

private String tno;

@Value("jason")

private String tname;

public String getTno() {

return tno;

}

@Value("1001")

public void setTno(String tno) {

this.tno = tno;

}

public String getTname() {

return tname;

}

public void setTname(String tname) {

this.tname = tname;

}

13.4、测试

package org.wuxin.ssm.annotation;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TeacherTest {

public static void main(String[] args) {

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

Teacher t = (Teacher) content.getBean("teacher");

System.out.println(t.getTno() + "," + t.getTname());

}

13.5、运行结果

14、自动装配autowire

14.1、创建 Cat 、Dog、Person 类

package org.wuxin.autowire;

public class Cat {

private String varieties;// 品种:猫的品种：虎斑

private double price;// 价格

// setter 、getter 方法

public String getVarieties() {

return varieties;

}

public void setVarieties(String varieties) {

this.varieties = varieties;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

// tostring

package org.wuxin.autowire;

public class Cat {

private String varieties;// 品种:猫的品种：虎斑

private double price;// 价格

// setter 、getter 方法

public String getVarieties() {

return varieties;

}

public void setVarieties(String varieties) {

this.varieties = varieties;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

// tostring

@Override

public String toString() {

return "Cat{" +

"品种='" + varieties + '\'' +

", 价格=" + price +

'}';

}

@Override

public String toString() {

return "Cat{" +

"品种='" + varieties + '\'' +

", 价格=" + price +

'}';

}

Dog 类：

package org.wuxin.autowire;

public class Dog {

private String varieties;// 品种:狗的品种：哈士奇

private double price;// 价格

// set 、get

public String getVarieties() {

return varieties;

}

public void setVarieties(String varieties) {

this.varieties = varieties;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

// tostring

@Override

public String toString() {

return "Dog{" +

"varieties='" + varieties + '\'' +

", price=" + price +

'}';

}

Person类：

package org.wuxin.autowire;

public class Person {

private String name;

private Cat cat;

private Dog dog;

// setter 、getter

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Cat getCat() {

return cat;

}

public void setCat(Cat cat) {

this.cat = cat;

}

public Dog getDog() {

return dog;

}

public void setDog(Dog dog) {

this.dog = dog;

}

// tostring

@Override

public String toString() {

return "Person{" +

"name='" + name + '\'' +

", cat=" + cat +

", dog=" + dog +

'}';

}

14.2、byName

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns=" http://www. springframework.org/sch ema/beans "

xmlns:xsi=" http://www. w3.org/2001/XMLSchema-i nstance "

xsi:schemaLocation=" http://www. springframework.org/sch ema/beans

http://www. springframework.org/sch ema/beans/spring-beans.xsd ">

</bean>

</bean>

<bean class="org.wuxin.autowire.Person" id="person" autowire="byName"><!--autowire自动装配

》byName: 首先我们通过在 Person 类中，

找 Persion类中的属性【name/cat/dog】,

然后在找到对应属性的 set方法【setCat 、setDog】

接下来把set方法后面的字符串首字母小写【setCat》cat 、setDog》dog】

拿到首字母小写的字符串【cat 、dog】

去spring 容器中查找是否有id值与之对应的bean

这样就完成了通过Person类属性名的自动装配

》byType

》constructor

》default/no

-->

<!-- <property name="cat" ref="cat"></property>

</bean>

</beans>

byName: 首先我们通过在 Person 类中，

找 Persion类中的属性【name/cat/dog】,

然后在找到对应属性的 set方法【setCat 、setDog】

接下来把set方法后面的字符串首字母小写【setCat》cat 、setDog》dog】

拿到首字母小写的字符串【cat 、dog】

去spring 容器中查找是否有id值与之对应的bean

这样就完成了通过Person类属性名的自动装配

编辑于 2021-11-30 15:39

发展趋势