Java复制代码static void bufferedFS() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream("/Users/fang/Images/题目.png");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("/Users/fang/Images/题目 output4.png");
            bos = new BufferedOutputStream(fos);
            int temp = 0;
            while((temp = bis.read())!=-1) {
                bos.write(temp);
            }
            bos.flush();
        } catch (Exception e) {
            e.printStackTrace();

        } finally {

            try { // 后开先关
                bos.close();
                bis.close();
                fos.close();
                fis.close();
                
//                if (bis!=null) {
//                    bis.close();
//                }
//                if (fis!=null) {
//                    fis.close();
//                }
//                if (bos!=null) {
//                    bos.close();
//                }
//                if (fos!=null) {
//                    fos.close();
//                }

            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

JavaScript复制代码var doms = document.getElementsByClassName('emoji_card_list');
for(var i=0;i<doms.length;i++){
    var tds = doms[i].getElementsByTagName('td');
    for(var j=0;j<tds.length;j++){
        var text = tds[j].innerText;
        if(text.indexOf('[') === 0 || text.indexOf('/')===0) {
            console.log(text);
        }
    }
}

text复制代码[让我看看] debugger eval code:7:21
[666] debugger eval code:7:21
[翻白眼] debugger eval code:7:21
/微笑 debugger eval code:7:21
/撇嘴 debugger eval code:7:21
/色 debugger eval code:7:21
/害羞 debugger eval code:7:21
/闭嘴 debugger eval code:7:21
/睡 debugger eval code:7:21
/旺柴 debugger eval code:7:21
/瓢虫

python复制代码data = """上面复制的大段内容，复制后回车"""
data_list = [x.split(' ')[0] for x in data.split('\n')]
emoji_list = []
for x in all_emoj:
    if x[0] == '/':
        emoji_list.append('[%s]' % x[1:])
    else:
        emoji_list.append(x)

python复制代码def remove_emoji(text):
    """
    去除文本中的表情符号，表情符号都是"[表情名称]" 这样的形式
    return: str
    """
    if '[' not in text:
        return text
    reg_expression = '|'.join([x.replace('[', '\[').replace(']', '\]') for x in emoji_list])
    pattern = re.compile(reg_expression)
    matched_words = pattern.findall(text)
    # 使用set去重，可以防止查找到多个的时候进行多次循环
    for matched_word in set(matched_words):
        text = text.replace(matched_word, '')
    return text

css复制代码>>> remove_emoji("[哈哈][闭嘴][闭嘴]")
'[哈哈]'

复制代码  我们之前是使用XML的方式来让Spring帮我们创建对象的，这样看起来非常麻烦，那么我们有没有什么简单的方式呢，答案是有的。

ini复制代码<context:component-scan base-package="com.albb"/>

less复制代码@Component 用在类上，相当于是Bean标签，id就是该类的类名首字母小写
    @Controller 用在web层上，相当于是Bean标签
    @Service  用在Service层上，相当于是Bean标签
    @Repository 用在dao层，配置一个Bean
    
    @Contorller,@Service,@Repository都相当于是@Component衍生出来的注解
    
    @Scope：配置Bean的作用范围，相当于bean的scope属性，用在类上
    @PostConstruct是指bean的初始化方法，用在初始化方法头上
    @PreDestory是指定bean的销毁方法，用在销毁方法上

less复制代码@AutoWired 相当于<property name="" ref="" ></property>
@Qualifer（要注入的bean的名称） 结合AutoWired使用，可以设置它的属性id，然后通过id来注入依赖
@Resource（要注入的bean的名称）：相当于@autoWired+@Qualifer
@Value（普通值）
@Value("${properties里的key}")
相当于property标签的value，注入普通属性<Property name="" value=""> </Property>

使用注解注入时，不需要使用set方法

kotlin复制代码1.创建一个配置类，打上@Configuration注解，
2.@CompoentScan（包名），用在配置类上，表示开启注解扫描
3.@ProperSource（配置文件），用在配置类上，加载properties文件，使用value属性指定properties的指定路径
4.@Import 用在配置类上，引入子配置类，用value属性指定子配置类的class
5.@Bean 用在配置类的方法上，把返回值声明为一个Bean，用name/value属性指定bean的id

java复制代码  /*
        3.使用@Bean注解标记的方法，方法内部需要用到spring工厂（容器）里面的某一个对象，怎么办？
            3.1 此时可以在方法的参数上，写上想要的对象参数即可
                a. 其实它就是在方法参数的前面，隐藏着一个注解： @Autowired
            3.2 但是也要考虑出现极端的情况：如果在spring的容器里面，有多个对象满足这个参数的类型，咋办？
                a. 搭配使用@Qualifier ，指定id值。
                b. 投机取巧，把方法的参数名字，写成id的名字即可

     */
    @Bean
    public QueryRunner runner03(@Qualifier("dataSource") DataSource ds){
        System.out.println("ds===" + ds);
        return new QueryRunner(ds);
    }

    @Bean
    public QueryRunner runner04(DataSource dataSource2){
        System.out.println("dataSource2===" + dataSource2);
        return new QueryRunner(dataSource2);
    }

    @Bean
    public DataSource dataSource() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        ds.setDriverClass(driverClass);
        ds.setJdbcUrl(jdbcUrl);
        ds.setUser(user);
        ds.setPassword(password);
        return ds;
    }
   @Bean
    public DataSource dataSource2() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        ds.setDriverClass(driverClass);
        ds.setJdbcUrl(jdbcUrl);
        ds.setUser(user);
        ds.setPassword(password);
        return ds;
    }
}

markdown复制代码* 数据是通过headless浏览器来采集（BOSS直聘网站做了预处理，不能直接通过get请求获取页面）
* 数据处理：大部分直接使用了js原生功能，使用了少量Lodash的分类功能
* 可视化视图 Echarts
* 词云使用 https://wordart.com/create
* 无头浏览器操作框架是puppeteer
* 页面解析cheerio

复制代码职位工资>10k 权重1.2
职位工资<10k 权重1
职位工资>15  权重1.5
各地区权重值总加和。

markdown复制代码什么是spring？
简单介绍一下就是一个开源的，轻量级的，面向切面的，简化企业开发的复杂性的框架。
spring有哪些优点呢？
1.方便解耦，简化开发
        通过spring提供的IOC容器，可以将对象间的依赖关系交由spring进行控制，避免硬编码所照成的过度程序耦合，从此我们就可以专注于写代码而不需要考虑其他的事情
2.spring的特性aop可以方便我们面向切面编程，从而实现程序的扩展
3.声明式事务的支持，可以让我们不在依赖于以往的编程式事务，通过声明式的方式可以更灵活的进行事务的管理，提高开发效率和质量
4.方便集成各种优秀的框架
5.降低对javaEE api的使用难度
6.Spring源码使用了大量的设计模式，设计巧妙，结构清晰，匠心独运，它的源码可以称的上是一个模板，非常值得我们进行学习。

复制代码IOC翻译过来就是控制反转的意思，那么什么是控制反转呢，大致的意思就是说原来程序是由程序控制的，后来控制权变了，这就是控制反转。
首先我们来看一段代码

ini复制代码    UserService userservice=new UserServiceImpl();
    关键就在这行代码，如果我们在dao层加一个实现类，想要调用mysql数据库怎么办
    是不是就要把newUserServiceImpl（）给改一下，这种硬编码造成的代码耦合性太强，我们就无法灵活的切换数据库，控制权始终在程序的手里。

复制代码1.创建Maven项目，导入依赖坐标，Spring的依赖坐标
2.编写Dao接口UserDao以及实现UserDao接口
3.创建Spring核心配置文件，并配置UserDaoImpl
4.测试：使用Spring的APi，获取Bean的实例对象

xml复制代码<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

csharp复制代码    public interface UserDao {
    void add();
    }

csharp复制代码public class UserDaoImpl implements UserDao {
    
   
    public  void add() {
        System.out.println("调用了UserDaoImpl的add方法~！~");
    }
}

xml复制代码<!--
    在这里告诉spring要创建哪个类的对象，并且给这个对象起一个别名

    bean标签：
            作用：用来托管（类）对象
            属性：
                id：是唯一标识，不能出现重复
                class：托管类的全路径
 -->
<bean id="ud"  class="com.itheima.dao.impl.UserDaoImpl" />

sql复制代码    scope：范围的意思，它的值主要用到的有2个
            value:singleton单例的，我们无论找工厂要多少次对象，永远是它
                  prototype多例的，我们找工厂要对象，每次的对象都不一样
    init-method：初始化方法，一般在对象创建的时候执行
    destory-method：销毁方法，在对象销毁的时候执行
    
    sping创建对象时默认调用的是无参构造
<bean id="ud" class="com.itheima.dao.impl.UserDaoImpl"  
      scope="singleton" init-method="" destroy-method="">
</bean>

lua复制代码刚才说了Spring可以为我们创建对象，那么属性该如何帮我们赋值呢
    没错----就是通过依赖注入

ini复制代码<bean id="" class="">
	<property name="属性名" value="属性值"></property>
    <property name="属性名" ref="bean的id"></property>
</bean>

ini复制代码 <bean id="" class="">
	<constructor-arg name="构造参数名称" value="构造参数的值"></constructor-arg>
    <constructor-arg name="构造参数名称" ref="bean的id"></constructor-arg>
</bean>

bash复制代码 <bean id="" class="" p:属性名="简单值" p:属性名-ref="bean的id"></bean>

xml复制代码 <!--导入进来db.properties-->
    <context:property-placeholder location="db.properties"/>

    <!--在下面使用 ${}来取值-->
    <bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${driverClass}"/>
        <property name="jdbcUrl" value="${jdbcUrl}"/>
        <property name="user" value="${user}"/>
        <property name="password" value="${password}"/>
    </bean>

ini复制代码    <import resource="classpath:applicationContext-service.xml"/>
    <import resource="classpath:applicationContext-dao.xml"/>

less复制代码@Runwith：用在测试类上，用于声明不在使用junit，而是使用spring运行环境
@ContextConfiguration：用在测试类上，用于指定spring配置类或配置文件，可以加载spring工厂

要使用以上注解要导入一下依赖

xml复制代码<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

less复制代码       @RunWith
        1. 表示使用的单元测试的环境，不再是以前的Junit的测试环境，而是spring针对Junit提供的测试环境
        2. 这套spring提供的测试环境在背后会帮助我们创建工厂。
    @ContextConfiguration
        1. 告诉spring的测试环境，配置文件在哪里？
        2. classpath: 这是固定写法，表示要在类路径底下找配置文件。
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestUserServiceImpl02 {

    //让spring把想要用到的对象给注入进来！
    // 这个注解是自动注入的意思，让spring把对象注入进来。
    @Autowired
    private UserService us;

    @Test
    public void testAdd(){

        /*ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService us = (UserService) context.getBean("us");
        */
        us.add();

    }
}

csharp复制代码Future<void> checkVersion() async {
  var version = await lookUpVersion();
  // Do something with version
}

csharp复制代码
String createOrderMessage() {
  var order = fetchUserOrder();
  return 'Your order is: $order';
}

Future<String> fetchUserOrder() =>
    Future.delayed(
      const Duration(seconds: 2),
      () => 'Order one!',
    );

void main() {
  print(createOrderMessage());
}

csharp复制代码Future<String> createOrderMessage() async {
  var order = await fetchUserOrder();
  return 'Your order is: $order';
}

Future<String> fetchUserOrder() =>
    Future.delayed(
      const Duration(seconds: 2),
      () => 'Large Latte',
    );

Future<void> main() async {
  print('Fetching user order...');
  print(await createOrderMessage());
}

csharp复制代码Future<String> fetchUserOrder() {
  return Future.delayed(const Duration(seconds: 2), () => 'Large Latte');
}

Future<void> fetchUserOrder() {
  return Future.delayed(const Duration(seconds: 2), () => print('Large Latte'));
}

csharp复制代码Future<void> fetchUserOrder() {
  return Future.delayed(const Duration(seconds: 2),
      () => throw Exception('Logout failed: user ID is invalid'));
}

dart复制代码try {
  print('Awaiting user order...');
  var order = await fetchUserOrder();
} catch (err) {
  print('Caught error: $err');
}

ini复制代码fetchUserOrder().then(order=>'do something');

java复制代码@WebListener
@Slf4j
public class Customlister implements ServletRequestListener{
​
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        log.info(" request监听器：销毁");
    }
​
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        log.info(" request监听器：可以在这里记录访问次数哦");
    }
​
}

java复制代码//注册器名称为customFilter,拦截的url为所有
@WebFilter(filterName="customFilter",urlPatterns={"/*"})
@Slf4j
public class CustomFilter implements Filter{
​
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("filter 初始化");
    }
​
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        log.info("customFilter 请求处理之前");
        //对request、response进行一些预处理
        // 比如设置请求编码
        // request.setCharacterEncoding("UTF-8");
        // response.setCharacterEncoding("UTF-8");
​
        //链路 直接传给下一个过滤器
        chain.doFilter(request, response);
​
        log.info("customFilter 请求处理之后");
    }
​
    @Override
    public void destroy() {
        log.info("filter 销毁");
    }
}

java复制代码@Configuration
public class FilterRegistration {
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //当过滤器有注入其他bean类时，可直接通过@bean的方式进行实体类过滤器，这样不可自动注入过滤器使用的其他bean类。
        //当然，若无其他bean需要获取时，可直接new CustomFilter()，也可使用getBean的方式。
        registration.setFilter(customFilter());
        //过滤器名称
        registration.setName("customFilter");
        //拦截路径
        registration.addUrlPatterns("/*");
        //设置顺序
        registration.setOrder(10);
        return registration;
    }
​
    @Bean
    public Filter customFilter() {
        return new CustomFilter();
    }
}

java复制代码@WebServlet(name = "firstServlet", urlPatterns = "/firstServlet") //标记为servlet，以便启动器扫描。
public class FirstServlet extends HttpServlet {
​
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().append("firstServlet");
    }
​
}

java复制代码@Slf4j
public class CustomHandlerInterceptor implements HandlerInterceptor{
​
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
   throws Exception {
  log.info("preHandle:请求前调用");
  //返回 false 则请求中断
  return true;
 }
​
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
   ModelAndView modelAndView) throws Exception {
  log.info("postHandle:请求后调用");
​
 }
​
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
   throws Exception {
  log.info("afterCompletion:请求调用完成后回调方法，即在视图渲染完成后回调");
​
 }
​
}

java复制代码@Configuration
//废弃：public class MyWebMvcConfigurer extends WebMvcConfigurerAdapter{
public class MyWebMvcConfigurer implements WebMvcConfigurer 
 @Override
  public void addInterceptors(InterceptorRegistry registry) {
   //注册拦截器 拦截规则
  //多个拦截器时 以此添加 执行顺序按添加顺序
  registry.addInterceptor(getHandlerInterceptor()).addPathPatterns("/*");
  }
    
 @Bean
 public static HandlerInterceptor getHandlerInterceptor() {
  return new CustomHandlerInterceptor();
 }
}

java复制代码@Slf4j
public class MyListener1 implements ApplicationListener<MyEvent> {
    public void onApplicationEvent(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener1.class.getName(), event.getSource()));
    }
}

java复制代码@SpringBootApplication
public class BootLaunchApplication {
​
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(BootLaunchApplication.class, args);
        //装载监听
        context.addApplicationListener(new MyListener1());
    }
}

java复制代码@Component
@Slf4j
public class MyListener2 implements ApplicationListener<MyEvent> {
​
    public void onApplicationEvent(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener2.class.getName(), event.getSource()));
    }
​
}

java复制代码@Slf4j
public class MyListener3 implements ApplicationListener<MyEvent> {
    public void onApplicationEvent(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener3.class.getName(), event.getSource()));
    }
}

yml复制代码context:
  listener:
    classes: club.krislin.customlistener.MyListener3

java复制代码@Slf4j
@Component
public class MyListener4 {
    @EventListener
    public void listener(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener4.class.getName(), event.getSource()));
    }
}

java复制代码@SuppressWarnings("serial")
public class MyEvent extends ApplicationEvent
{
 public MyEvent(Object source)
 {
  super(source);
 }
}

java复制代码@RunWith(SpringRunner.class)
@SpringBootTest
public class CustomListenerTest {
​
    @Resource private
    ApplicationContext applicationContext;
​
    @Test
    public void testEvent(){
        applicationContext.publishEvent(new MyEvent("测试事件."));
    }
}